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


  22. package org.openspcoop2.pdd.services.core;

  24. import java.io.ByteArrayInputStream;
  25. import java.io.Serializable;
  26. import java.util.ArrayList;
  27. import java.util.Date;
  28. import java.util.Enumeration;
  29. import java.util.HashMap;
  30. import java.util.List;
  31. import java.util.Map;

  33. import javax.servlet.http.HttpServletRequest;

  35. import org.apache.commons.lang.StringUtils;
  36. import org.openspcoop2.core.config.AttributeAuthority;
  37. import org.openspcoop2.core.config.Connettore;
  38. import org.openspcoop2.core.config.CorrelazioneApplicativa;
  39. import org.openspcoop2.core.config.CorsConfigurazione;
  40. import org.openspcoop2.core.config.DumpConfigurazione;
  41. import org.openspcoop2.core.config.GestioneTokenAutenticazione;
  42. import org.openspcoop2.core.config.PortaApplicativa;
  43. import org.openspcoop2.core.config.PortaDelegata;
  44. import org.openspcoop2.core.config.Proprieta;
  45. import org.openspcoop2.core.config.ResponseCachingConfigurazione;
  46. import org.openspcoop2.core.config.ServizioApplicativo;
  47. import org.openspcoop2.core.config.ValidazioneContenutiApplicativi;
  48. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  49. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  50. import org.openspcoop2.core.config.constants.TipoGestioneCORS;
  51. import org.openspcoop2.core.config.driver.DriverConfigurazioneNotFound;
  52. import org.openspcoop2.core.constants.CostantiConnettori;
  53. import org.openspcoop2.core.constants.TipoPdD;
  54. import org.openspcoop2.core.id.IDPortaApplicativa;
  55. import org.openspcoop2.core.id.IDPortaDelegata;
  56. import org.openspcoop2.core.id.IDServizio;
  57. import org.openspcoop2.core.id.IDServizioApplicativo;
  58. import org.openspcoop2.core.id.IDSoggetto;
  59. import org.openspcoop2.core.id.IdentificativiFruizione;
  60. import org.openspcoop2.core.registry.AccordoServizioParteComune;
  61. import org.openspcoop2.core.registry.AccordoServizioParteSpecifica;
  62. import org.openspcoop2.core.registry.Resource;
  63. import org.openspcoop2.core.registry.driver.DriverRegistroServiziAzioneNotFound;
  64. import org.openspcoop2.core.registry.driver.DriverRegistroServiziCorrelatoNotFound;
  65. import org.openspcoop2.core.registry.driver.DriverRegistroServiziException;
  66. import org.openspcoop2.core.registry.driver.DriverRegistroServiziNotFound;
  67. import org.openspcoop2.core.registry.driver.DriverRegistroServiziPortTypeNotFound;
  68. import org.openspcoop2.core.registry.driver.IDAccordoFactory;
  69. import org.openspcoop2.core.registry.driver.IDServizioFactory;
  70. import org.openspcoop2.message.OpenSPCoop2Message;
  71. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  72. import org.openspcoop2.message.constants.MessageRole;
  73. import org.openspcoop2.message.constants.ServiceBinding;
  74. import org.openspcoop2.message.exception.ParseException;
  75. import org.openspcoop2.message.soap.TunnelSoapUtils;
  76. import org.openspcoop2.message.soap.mtom.MtomXomReference;
  77. import org.openspcoop2.message.utils.MessageUtilities;
  78. import org.openspcoop2.pdd.config.ClassNameProperties;
  79. import org.openspcoop2.pdd.config.ConfigurazioneCanaliNodo;
  80. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  81. import org.openspcoop2.pdd.config.CostantiProprieta;
  82. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  83. import org.openspcoop2.pdd.config.RichiestaApplicativa;
  84. import org.openspcoop2.pdd.config.RichiestaDelegata;
  85. import org.openspcoop2.pdd.config.dynamic.PddPluginLoader;
  86. import org.openspcoop2.pdd.core.AbstractCore;
  87. import org.openspcoop2.pdd.core.CORSFilter;
  88. import org.openspcoop2.pdd.core.CORSWrappedHttpServletResponse;
  89. import org.openspcoop2.pdd.core.CostantiPdD;
  90. import org.openspcoop2.pdd.core.GestoreCorrelazioneApplicativa;
  91. import org.openspcoop2.pdd.core.GestoreCorrelazioneApplicativaConfig;
  92. import org.openspcoop2.pdd.core.GestoreMessaggi;
  93. import org.openspcoop2.pdd.core.GestoreMessaggiException;
  94. import org.openspcoop2.pdd.core.IntegrationContext;
  95. import org.openspcoop2.pdd.core.LocalForwardEngine;
  96. import org.openspcoop2.pdd.core.LocalForwardParameter;
  97. import org.openspcoop2.pdd.core.PdDContext;
  98. import org.openspcoop2.pdd.core.ProtocolContext;
  99. import org.openspcoop2.pdd.core.StatoServiziPdD;
  100. import org.openspcoop2.pdd.core.ValidatoreMessaggiApplicativi;
  101. import org.openspcoop2.pdd.core.ValidatoreMessaggiApplicativiException;
  102. import org.openspcoop2.pdd.core.ValidatoreMessaggiApplicativiRest;
  103. import org.openspcoop2.pdd.core.autorizzazione.GestoreAutorizzazione;
  104. import org.openspcoop2.pdd.core.autorizzazione.container.AutorizzazioneHttpServletRequest;
  105. import org.openspcoop2.pdd.core.autorizzazione.container.IAutorizzazioneSecurityContainer;
  106. import org.openspcoop2.pdd.core.autorizzazione.pd.DatiInvocazionePortaDelegata;
  107. import org.openspcoop2.pdd.core.autorizzazione.pd.EsitoAutorizzazionePortaDelegata;
  108. import org.openspcoop2.pdd.core.connettori.InfoConnettoreIngresso;
  109. import org.openspcoop2.pdd.core.credenziali.Credenziali;
  110. import org.openspcoop2.pdd.core.credenziali.GestoreCredenzialiConfigurationException;
  111. import org.openspcoop2.pdd.core.credenziali.IGestoreCredenziali;
  112. import org.openspcoop2.pdd.core.handlers.GestoreHandlers;
  113. import org.openspcoop2.pdd.core.handlers.HandlerException;
  114. import org.openspcoop2.pdd.core.handlers.InRequestContext;
  115. import org.openspcoop2.pdd.core.handlers.InRequestProtocolContext;
  116. import org.openspcoop2.pdd.core.handlers.OutResponseContext;
  117. import org.openspcoop2.pdd.core.integrazione.HeaderIntegrazione;
  118. import org.openspcoop2.pdd.core.integrazione.IGestoreIntegrazionePD;
  119. import org.openspcoop2.pdd.core.integrazione.IGestoreIntegrazionePDSoap;
  120. import org.openspcoop2.pdd.core.integrazione.InRequestPDMessage;
  121. import org.openspcoop2.pdd.core.integrazione.OutResponsePDMessage;
  122. import org.openspcoop2.pdd.core.node.INodeReceiver;
  123. import org.openspcoop2.pdd.core.node.INodeSender;
  124. import org.openspcoop2.pdd.core.node.NodeTimeoutException;
  125. import org.openspcoop2.pdd.core.response_caching.HashGenerator;
  126. import org.openspcoop2.pdd.core.state.IOpenSPCoopState;
  127. import org.openspcoop2.pdd.core.state.OpenSPCoopState;
  128. import org.openspcoop2.pdd.core.state.OpenSPCoopStateful;
  129. import org.openspcoop2.pdd.core.state.OpenSPCoopStateless;
  130. import org.openspcoop2.pdd.core.token.GestoreToken;
  131. import org.openspcoop2.pdd.core.token.InformazioniToken;
  132. import org.openspcoop2.pdd.core.token.attribute_authority.EsitoRecuperoAttributi;
  133. import org.openspcoop2.pdd.core.token.attribute_authority.InformazioniAttributi;
  134. import org.openspcoop2.pdd.core.token.attribute_authority.PolicyAttributeAuthority;
  135. import org.openspcoop2.pdd.core.token.attribute_authority.pd.GestioneAttributeAuthority;
  136. import org.openspcoop2.pdd.core.transazioni.Transaction;
  137. import org.openspcoop2.pdd.core.transazioni.TransactionContext;
  138. import org.openspcoop2.pdd.logger.Dump;
  139. import org.openspcoop2.pdd.logger.MsgDiagnosticiProperties;
  140. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  141. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  142. import org.openspcoop2.pdd.logger.Tracciamento;
  143. import org.openspcoop2.pdd.mdb.ConsegnaContenutiApplicativi;
  144. import org.openspcoop2.pdd.mdb.EsitoLib;
  145. import org.openspcoop2.pdd.mdb.ImbustamentoMessage;
  146. import org.openspcoop2.pdd.mdb.InoltroBuste;
  147. import org.openspcoop2.pdd.mdb.SbustamentoRisposte;
  148. import org.openspcoop2.pdd.services.OpenSPCoop2Startup;
  149. import org.openspcoop2.pdd.services.ServicesUtils;
  150. import org.openspcoop2.pdd.services.connector.messages.ConnectorInMessage;
  151. import org.openspcoop2.pdd.services.error.AbstractErrorGenerator;
  152. import org.openspcoop2.pdd.services.error.RicezioneContenutiApplicativiInternalErrorGenerator;
  153. import org.openspcoop2.pdd.services.skeleton.IntegrationManager;
  154. import org.openspcoop2.pdd.timers.TimerGestoreMessaggi;
  155. import org.openspcoop2.pdd.timers.TimerLock;
  156. import org.openspcoop2.pdd.timers.TimerMonitoraggioRisorseThread;
  157. import org.openspcoop2.pdd.timers.TimerThresholdThread;
  158. import org.openspcoop2.pdd.timers.TipoLock;
  159. import org.openspcoop2.protocol.basic.registry.IdentificazionePortaDelegata;
  160. import org.openspcoop2.protocol.engine.ProtocolFactoryManager;
  161. import org.openspcoop2.protocol.engine.builder.Imbustamento;
  162. import org.openspcoop2.protocol.engine.constants.Costanti;
  163. import org.openspcoop2.protocol.engine.driver.RepositoryBuste;
  164. import org.openspcoop2.protocol.engine.mapping.IdentificazioneDinamicaException;
  165. import org.openspcoop2.protocol.engine.validator.ValidazioneSintattica;
  166. import org.openspcoop2.protocol.registry.RegistroServiziManager;
  167. import org.openspcoop2.protocol.sdk.Busta;
  168. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  169. import org.openspcoop2.protocol.sdk.Integrazione;
  170. import org.openspcoop2.protocol.sdk.ProtocolException;
  171. import org.openspcoop2.protocol.sdk.ProtocolMessage;
  172. import org.openspcoop2.protocol.sdk.Servizio;
  173. import org.openspcoop2.protocol.sdk.builder.IBustaBuilder;
  174. import org.openspcoop2.protocol.sdk.builder.ProprietaErroreApplicativo;
  175. import org.openspcoop2.protocol.sdk.builder.ProprietaManifestAttachments;
  176. import org.openspcoop2.protocol.sdk.config.IProtocolConfiguration;
  177. import org.openspcoop2.protocol.sdk.config.IProtocolManager;
  178. import org.openspcoop2.protocol.sdk.config.IProtocolVersionManager;
  179. import org.openspcoop2.protocol.sdk.config.ITraduttore;
  180. import org.openspcoop2.protocol.sdk.constants.CodiceErroreIntegrazione;
  181. import org.openspcoop2.protocol.sdk.constants.ErroreIntegrazione;
  182. import org.openspcoop2.protocol.sdk.constants.ErroriIntegrazione;
  183. import org.openspcoop2.protocol.sdk.constants.FaseSbustamento;
  184. import org.openspcoop2.protocol.sdk.constants.FunzionalitaProtocollo;
  185. import org.openspcoop2.protocol.sdk.constants.IntegrationFunctionError;
  186. import org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione;
  187. import org.openspcoop2.protocol.sdk.constants.RuoloMessaggio;
  188. import org.openspcoop2.protocol.sdk.constants.StatoFunzionalitaProtocollo;
  189. import org.openspcoop2.protocol.sdk.dump.DumpException;
  190. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  191. import org.openspcoop2.protocol.sdk.state.URLProtocolContext;
  192. import org.openspcoop2.protocol.sdk.tracciamento.TracciamentoException;
  193. import org.openspcoop2.utils.LoggerWrapperFactory;
  194. import org.openspcoop2.utils.MapKey;
  195. import org.openspcoop2.utils.Utilities;
  196. import org.openspcoop2.utils.date.DateManager;
  197. import org.openspcoop2.utils.resources.Loader;
  198. import org.openspcoop2.utils.transport.http.CORSRequestType;
  199. import org.openspcoop2.utils.transport.http.HttpConstants;
  200. import org.openspcoop2.utils.transport.http.HttpRequestMethod;
  201. import org.slf4j.Logger;

  203. /**
  204.  * Implementazione del servizio RicezioneContenutiApplicativi di OpenSPCoop
  205.  * 
  206.  * @author Poli Andrea (apoli@link.it)
  207.  * @author $Author$
  208.  * @version $Rev$, $Date$
  209.  */

  211. public class RicezioneContenutiApplicativi {

  213.     /**
  214.      * Variabile che indica il Nome del modulo dell'architettura di OpenSPCoop
  215.      * rappresentato da questa classe
  216.      */
  217.     public static final String ID_MODULO = "RicezioneContenutiApplicativi";
  218.     
  219.     private static void logDebug(Logger logCore, String msg) {
  220.         logCore.debug(msg);
  221.     }
  222.     private static void logDebug(Logger logCore, String msg, Throwable e) {
  223.         logCore.debug(msg, e);
  224.     }
  225.     private static void logInfo(Logger logCore, String msg) {
  226.         logCore.info(msg);
  227.     }
  228.     private static void logError(Logger logCore, String msg) {
  229.         logCore.error(msg);
  230.     }
  231.     private static void logError(Logger logCore, String msg, Throwable e) {
  232.         logCore.error(msg,e);
  233.     }
  234.     
  235.     

  237.     /** Indicazione se sono state inizializzate le variabili del servizio */
  238.     public static boolean initializeService = false;

  240.     /** IGestoreIntegrazionePD: lista di gestori, ordinati per priorita' minore */
  241.     private static String[] defaultGestoriIntegrazionePD = null;
  242.     private static java.util.concurrent.ConcurrentHashMap<String, String[]> defaultPerProtocolloGestoreIntegrazionePD = null;

  244.     /** IGestoreCredenziali: lista di gestori delle credenziali */
  245.     private static String [] tipiGestoriCredenziali = null;
  246.     
  247.     /**
  248.      * Inizializzatore del servizio RicezioneContenutiApplicativi
  249.      * 
  250.      * @throws Exception
  251.      */
  252.     public static synchronized void initializeService(
  253.             ConfigurazionePdDManager configReader,
  254.             ClassNameProperties className,
  255.             OpenSPCoop2Properties propertiesReader, Logger logCore)
  256.             throws Exception {
  257.         if (RicezioneContenutiApplicativi.initializeService)
  258.             return; // inizializzato da un altro thread

  260.         Loader loader = Loader.getInstance();
  261.         PddPluginLoader pluginLoader = PddPluginLoader.getInstance();
  262.         
  263.         // Inizializzazione NodeSender
  264.         String classTypeNodeSender = className.getNodeSender(propertiesReader.getNodeSender());
  265.         try {
  266.             INodeSender nodeSender = (INodeSender) loader.newInstance(classTypeNodeSender);
  267.             nodeSender.toString();
  268.             logInfo(logCore, "Inizializzazione gestore NodeSender di tipo " + classTypeNodeSender + " effettuata.");
  269.         } catch (Exception e) {
  270.             throw new Exception(
  271.                     "Riscontrato errore durante il caricamento della classe ["+ classTypeNodeSender
  272.                             + "] da utilizzare per la spedizione nell'infrastruttura: " + e.getMessage());
  273.         }

  275.         // Inizializzazione NodeReceiver
  276.         String classType = className.getNodeReceiver(propertiesReader.getNodeReceiver());
  277.         try {
  278.             INodeReceiver nodeReceiver = (INodeReceiver) loader.newInstance(classType);
  279.             nodeReceiver.toString();
  280.             logInfo(logCore, "Inizializzazione gestore NodeReceiver di tipo "+ classType + " effettuata.");
  281.         } catch (Exception e) {
  282.             throw new Exception(
  283.                     "Riscontrato errore durante il caricamento della classe ["+ classType
  284.                             + "] da utilizzare per la ricezione dall'infrastruttura: "+ e.getMessage());
  285.         }

  287.         // Inizializzo IGestoreIntegrazionePD list
  288.         RicezioneContenutiApplicativi.defaultGestoriIntegrazionePD = propertiesReader.getTipoIntegrazionePD();
  289.         for (int i = 0; i < RicezioneContenutiApplicativi.defaultGestoriIntegrazionePD.length; i++) {
  290.             try {
  291.                 IGestoreIntegrazionePD gestore = (IGestoreIntegrazionePD) pluginLoader.newIntegrazionePortaDelegata(RicezioneContenutiApplicativi.defaultGestoriIntegrazionePD[i]);
  292.                 gestore.toString();
  293.                 logInfo(logCore, "Inizializzazione gestore dati di integrazione per le fruizioni di tipo "
  294.                                 + RicezioneContenutiApplicativi.defaultGestoriIntegrazionePD[i] + " effettuata.");
  295.             } catch (Exception e) {
  296.                 throw new Exception(e.getMessage(),e);
  297.             }
  298.         }
  299.         
  300.         // Inizializzo IGestoreIntegrazionePD per protocollo
  301.         RicezioneContenutiApplicativi.defaultPerProtocolloGestoreIntegrazionePD = new java.util.concurrent.ConcurrentHashMap<String, String[]>();
  302.         Enumeration<String> enumProtocols = ProtocolFactoryManager.getInstance().getProtocolNames();
  303.         while (enumProtocols.hasMoreElements()) {
  304.             String protocol = (String) enumProtocols.nextElement();
  305.             String[] tipiIntegrazionePD = propertiesReader.getTipoIntegrazionePD(protocol);
  306.             if(tipiIntegrazionePD!=null && tipiIntegrazionePD.length>0){
  307.                 List<String> tipiIntegrazionePerProtocollo = new ArrayList<>();
  308.                 for (int i = 0; i < tipiIntegrazionePD.length; i++) {
  309.                     try {
  310.                         IGestoreIntegrazionePD gestore = (IGestoreIntegrazionePD) pluginLoader.newIntegrazionePortaDelegata(tipiIntegrazionePD[i]);
  311.                         gestore.toString();
  312.                         tipiIntegrazionePerProtocollo.add(tipiIntegrazionePD[i]);
  313.                         logCore .info("Inizializzazione gestore dati di integrazione (protocollo: "+protocol+") per le fruizioni di tipo "
  314.                                 + tipiIntegrazionePD[i] + " effettuata.");
  315.                     } catch (Exception e) {
  316.                         throw new Exception(e.getMessage(),e);
  317.                     }
  318.                 }
  319.                 if(tipiIntegrazionePerProtocollo.size()>0){
  320.                     RicezioneContenutiApplicativi.defaultPerProtocolloGestoreIntegrazionePD.put(protocol, tipiIntegrazionePerProtocollo.toArray(new String[1]));
  321.                 }
  322.             }
  323.         }

  325.         // Inizializzo GestoriCredenziali PD
  326.         RicezioneContenutiApplicativi.tipiGestoriCredenziali = propertiesReader.getTipoGestoreCredenzialiPD();
  327.         if(RicezioneContenutiApplicativi.tipiGestoriCredenziali!=null){
  328.             for (int i = 0; i < RicezioneContenutiApplicativi.tipiGestoriCredenziali.length; i++) {
  329.                 classType = className.getGestoreCredenziali(RicezioneContenutiApplicativi.tipiGestoriCredenziali[i]);
  330.                 try {
  331.                     IGestoreCredenziali gestore = (IGestoreCredenziali)loader.newInstance(classType);
  332.                     gestore.toString();
  333.                     logCore .info("Inizializzazione gestore credenziali di tipo "
  334.                             + RicezioneContenutiApplicativi.tipiGestoriCredenziali[i]   + " effettuata.");
  335.                 } catch (Exception e) {
  336.                     throw new Exception(
  337.                             "Riscontrato errore durante il caricamento della classe ["+ classType
  338.                             + "] da utilizzare per la gestione delle credenziali di tipo ["
  339.                             + RicezioneContenutiApplicativi.tipiGestoriCredenziali[i]+ "]: " + e.getMessage());
  340.                 }
  341.             }
  342.         }
  343.         
  344.         RicezioneContenutiApplicativi.initializeService = true;
  345.     }



  349.     /** Generatore Errori */
  350.     private RicezioneContenutiApplicativiInternalErrorGenerator generatoreErrore;
  351.     
  352.     /** Contesto della richiesta */
  353.     private RicezioneContenutiApplicativiContext msgContext;
  354.     
  355.     public RicezioneContenutiApplicativi(
  356.             RicezioneContenutiApplicativiContext context,
  357.             RicezioneContenutiApplicativiInternalErrorGenerator generatoreErrore) {
  358.         this.msgContext = context;
  359.         this.generatoreErrore = generatoreErrore;
  360.     }

  362.     public void process(Object ... params) {
  363.                 
  364.         
  365.         // ------------- dati generali -----------------------------
  366.         
  367.         // Context
  368.         PdDContext context = this.msgContext.getPddContext();
  369.         
  370.         // Logger
  371.         Logger logCore = OpenSPCoop2Logger.getLoggerOpenSPCoopCore();
  372.         if (logCore == null) {
  373.             logCore = LoggerWrapperFactory.getLogger(RicezioneContenutiApplicativi.ID_MODULO);
  374.         }
  375.         
  376.         // MsgDiagnostico
  377.         MsgDiagnostico msgDiag = this.msgContext.getMsgDiagnostico();
  378.         
  379.         // Messaggio
  380.         OpenSPCoop2Message requestMessage = this.msgContext.getMessageRequest();
  381.         if (requestMessage == null) {
  382.             setSOAPFault(IntegrationFunctionError.INTERNAL_REQUEST_ERROR, logCore, msgDiag, new Exception("Request message is null"), "LetturaMessaggioRichiesta");
  383.             return;
  384.         }
  385.         
  386.         
  387.         
  388.         
  389.         // ------------- in-handler -----------------------------
  390.         IProtocolFactory<?> protocolFactory = null;
  391.         try{
  392.             if(context==null) {
  393.                 throw new Exception("Context is null");
  394.             }
  395.             protocolFactory = ProtocolFactoryManager.getInstance().getProtocolFactoryByName((String)context.getObject(org.openspcoop2.core.constants.Costanti.PROTOCOL_NAME));
  396.         }catch(Exception e){
  397.             setSOAPFault(IntegrationFunctionError.GOVWAY_NOT_INITIALIZED, logCore, msgDiag, e, "ProtocolFactoryInstance");
  398.             return;
  399.         }
  400.         InRequestContext inRequestContext = new InRequestContext(logCore,protocolFactory, null);
  401.         // TipoPorta
  402.         inRequestContext.setTipoPorta(TipoPdD.DELEGATA);
  403.         inRequestContext.setIdModulo(this.msgContext.getIdModulo());
  404.         // Informazioni connettore ingresso
  405.         InfoConnettoreIngresso connettore = new InfoConnettoreIngresso();
  406.         connettore.setCredenziali(this.msgContext.getCredenziali());
  407.         if(this.msgContext.getUrlProtocolContext()!=null && 
  408.                 this.msgContext.getUrlProtocolContext().getHttpServletRequest()!=null){
  409.             OpenSPCoop2Properties properties = OpenSPCoop2Properties.getInstance(); // Puo' non essere inizializzato
  410.             if(properties!=null){
  411.                 String tipo = properties.getRealContainerCustom();
  412.                 if(tipo!=null) {
  413.                     try {
  414.                         ClassNameProperties className = ClassNameProperties.getInstance();
  415.                         Loader loader = Loader.getInstance();
  416.                         // Check tipi registrati
  417.                         String tipoClass = className.getRealmContainerCustom(tipo);
  418.                         IAutorizzazioneSecurityContainer authEngine = (IAutorizzazioneSecurityContainer) loader.newInstance(tipoClass);
  419.                         authEngine.init(this.msgContext.getUrlProtocolContext().getHttpServletRequest(), 
  420.                                 context, protocolFactory);
  421.                         AutorizzazioneHttpServletRequest httpServletRequestAuth = new AutorizzazioneHttpServletRequest(this.msgContext.getUrlProtocolContext().getHttpServletRequest(), authEngine);
  422.                         this.msgContext.getUrlProtocolContext().updateHttpServletRequest(httpServletRequestAuth);                   
  423.                     }catch(Exception e){
  424.                         setSOAPFault(IntegrationFunctionError.INTERNAL_REQUEST_ERROR, logCore, msgDiag, e, "AutorizzazioneSecurityContainerInstance");
  425.                         return;
  426.                     }
  427.                 }
  428.             }
  429.         }
  430.         connettore.setUrlProtocolContext(this.msgContext.getUrlProtocolContext());
  431.         if(ServiceBinding.SOAP.equals(requestMessage.getServiceBinding())){
  432.             try{
  433.                 connettore.setSoapAction(requestMessage.castAsSoap().getSoapAction());
  434.             }catch(Exception e){
  435.                 setSOAPFault(IntegrationFunctionError.INTERNAL_REQUEST_ERROR, logCore,msgDiag, e, "LetturaSoapAction");
  436.                 return;
  437.             }
  438.         }
  439.         connettore.setFromLocation(this.msgContext.getSourceLocation());
  440.         inRequestContext.setConnettore(connettore);
  441.         // Data accettazione richiesta
  442.         inRequestContext.setDataAccettazioneRichiesta(this.msgContext.getDataAccettazioneRichiesta());
  443.         // Data ingresso richiesta
  444.         inRequestContext.setDataElaborazioneMessaggio(this.msgContext.getDataIngressoRichiesta());
  445.         // PdDContext
  446.         inRequestContext.setPddContext(context);
  447.         // Dati Messaggio
  448.         inRequestContext.setMessaggio(requestMessage);
  449.         // Invoke handler
  450.         try{
  451.             GestoreHandlers.inRequest(inRequestContext, msgDiag, logCore);
  452.         }catch(HandlerException e){
  453.             setSOAPFault(IntegrationFunctionError.INTERNAL_REQUEST_ERROR, logCore,msgDiag, e, e.getIdentitaHandler());
  454.             return;
  455.         }catch(Exception e){
  456.             setSOAPFault(IntegrationFunctionError.INTERNAL_REQUEST_ERROR, logCore,msgDiag, e, "InvocazioneInRequestHandler");
  457.             return;
  458.         }
  459.         
  460.         
  461.         
  462.         
  463.         
  464.             
  465.         // ------------- process -----------------------------
  466.         HashMap<String, Object> internalObjects = new HashMap<>();
  467.         try{
  468.             process_engine(inRequestContext,internalObjects,params);
  469.         } catch(TracciamentoException e){
  470.             setSOAPFault(AbstractErrorGenerator.getIntegrationInternalError(context), logCore,msgDiag, e, "TracciamentoNonRiuscito");
  471.             return;
  472.         } catch(DumpException e){
  473.             setSOAPFault(AbstractErrorGenerator.getIntegrationInternalError(context), logCore,msgDiag, e, "DumpNonRiuscito");
  474.             return;
  475.         } catch(ProtocolException e){
  476.             setSOAPFault(AbstractErrorGenerator.getIntegrationInternalError(context), logCore,msgDiag, e, "InstanziazioneProtocolFactoryNonRiuscita");
  477.             return;
  478.         } 
  479.         
  480.         try{
  481.             if(context!=null  && this.msgContext.getIntegrazione()!=null){
  482.                 if(context.containsKey(CostantiPdD.TIPO_PROCESSAMENTO_MTOM_RICHIESTA)){
  483.                     this.msgContext.getIntegrazione().setTipoProcessamentoMtomXopRichiesta(
  484.                             (String)context.getObject(CostantiPdD.TIPO_PROCESSAMENTO_MTOM_RICHIESTA));
  485.                 }
  486.                 if(context.containsKey(CostantiPdD.TIPO_PROCESSAMENTO_MTOM_RISPOSTA)){
  487.                     this.msgContext.getIntegrazione().setTipoProcessamentoMtomXopRisposta(
  488.                             (String)context.getObject(CostantiPdD.TIPO_PROCESSAMENTO_MTOM_RISPOSTA));
  489.                 }
  490.                 if(context.containsKey(CostantiPdD.TIPO_SICUREZZA_MESSAGGIO_RICHIESTA)){
  491.                     this.msgContext.getIntegrazione().setTipoMessageSecurityRichiesta(
  492.                             (String)context.getObject(CostantiPdD.TIPO_SICUREZZA_MESSAGGIO_RICHIESTA));
  493.                 }
  494.                 if(context.containsKey(CostantiPdD.TIPO_SICUREZZA_MESSAGGIO_RISPOSTA)){
  495.                     this.msgContext.getIntegrazione().setTipoMessageSecurityRisposta(
  496.                             (String)context.getObject(CostantiPdD.TIPO_SICUREZZA_MESSAGGIO_RISPOSTA));
  497.                 }
  498.             }
  499.         }catch(Exception e){
  500.             setSOAPFault(AbstractErrorGenerator.getIntegrationInternalError(context), logCore,msgDiag, e, "FinalizeIntegrationContextRicezioneContenutiApplicativi");
  501.             return;
  502.         }
  503.         
  504.         
  505.         

  507.         
  508.         
  509.         
  510.         
  511.         // ------------- Dump richiesta in ingresso -----------------------------
  512.         if(!internalObjects.containsKey(CostantiPdD.DUMP_RICHIESTA_EFFETTUATO) &&
  513.             Dump.isSistemaDumpDisponibile()){
  514.             try{
  515.                 ConfigurazionePdDManager configurazionePdDReader = ConfigurazionePdDManager.getInstance();  
  516.                 
  517.                 if(internalObjects.containsKey(CostantiPdD.DUMP_CONFIG)==false) {
  518.                     URLProtocolContext urlProtocolContext = this.msgContext.getUrlProtocolContext();
  519.                     if(urlProtocolContext!=null && urlProtocolContext.getInterfaceName()!=null) {
  520.                         IDPortaDelegata identificativoPortaDelegata = new IDPortaDelegata();
  521.                         identificativoPortaDelegata.setNome(urlProtocolContext.getInterfaceName());
  522.                         PortaDelegata portaDelegata = configurazionePdDReader.getPortaDelegataSafeMethod(identificativoPortaDelegata, this.msgContext.getRequestInfo());
  523.                         if(portaDelegata!=null) {
  524.                             DumpConfigurazione dumpConfig = configurazionePdDReader.getDumpConfigurazione(portaDelegata);
  525.                             internalObjects.put(CostantiPdD.DUMP_CONFIG, dumpConfig);
  526.                         }
  527.                     }
  528.                 }
  529.                 
  530.                 OpenSPCoop2Message msgRichiesta = inRequestContext.getMessaggio();
  531.                 if (msgRichiesta!=null) {
  532.                     
  533.                     Dump dumpApplicativo = getDump(configurazionePdDReader, protocolFactory, internalObjects, msgDiag.getPorta());
  534.                     dumpApplicativo.dumpRichiestaIngresso(msgRichiesta, 
  535.                             inRequestContext.getConnettore().getUrlProtocolContext());
  536.                 }
  537.             }catch(DumpException e){
  538.                 setSOAPFault(AbstractErrorGenerator.getIntegrationInternalError(context), logCore,msgDiag, e, "DumpNonRiuscito");
  539.                 return;
  540.             }catch(Exception e){
  541.                 // Se non riesco ad accedere alla configurazione sicuramente gia' nel messaggio di risposta e' presente l'errore di PdD non correttamente inizializzata
  542.             }
  543.         }
  544.         
  545.         
  546.         
  547.         
  548.         
  549.         // ------------- out-handler -----------------------------
  550.         OutResponseContext outResponseContext = new OutResponseContext(logCore,protocolFactory, null);
  551.         // TipoPorta
  552.         outResponseContext.setTipoPorta(this.msgContext.getTipoPorta());
  553.         outResponseContext.setIdModulo(this.msgContext.getIdModulo());
  554.         // DataUscitaMessaggio
  555.         outResponseContext.setDataElaborazioneMessaggio(DateManager.getDate());
  556.         // PddContext
  557.         outResponseContext.setPddContext(inRequestContext.getPddContext());
  558.         // Informazioni protocollo e di integrazione
  559.         outResponseContext.setProtocollo(this.msgContext.getProtocol());
  560.         outResponseContext.setIntegrazione(this.msgContext.getIntegrazione());
  561.         // Header di trasporto della risposta
  562.         outResponseContext.setResponseHeaders(this.msgContext.getResponseHeaders());
  563.         // Messaggio
  564.         OpenSPCoop2Message msgResponse = this.msgContext.getMessageResponse();
  565.         outResponseContext.setMessaggio(msgResponse);
  566.         // Invoke handler
  567.         try{
  568.             GestoreHandlers.outResponse(outResponseContext, msgDiag, logCore);
  569.         }catch(HandlerException e){
  570.             setSOAPFault(AbstractErrorGenerator.getIntegrationInternalError(context), logCore,msgDiag, e, e.getIdentitaHandler());
  571.             return;
  572.         }catch(Exception e){
  573.             setSOAPFault(AbstractErrorGenerator.getIntegrationInternalError(context), logCore,msgDiag, e, "InvocazioneOutResponseHandler");
  574.             return;
  575.         }
  576.         

  578.         
  579.         
  580.         
  581.         // ---------------- fine gestione ------------------------------
  582.         OpenSPCoop2Message msgRisposta = null;
  583.         try{
  584.             msgRisposta = outResponseContext.getMessaggio();
  585.             boolean rispostaPresente = true;
  586.             OpenSPCoop2Properties properties = OpenSPCoop2Properties.getInstance(); // Puo' non essere inizializzato
  587.             if(properties!=null){
  588.                 rispostaPresente = ServicesUtils.verificaRispostaRelazioneCodiceTrasporto202(protocolFactory,OpenSPCoop2Properties.getInstance(), msgRisposta,true);
  589.             }
  590.             if(rispostaPresente){
  591.                 this.msgContext.setMessageResponse(msgRisposta);
  592.             }else{
  593.                 this.msgContext.setMessageResponse(null);
  594.                 msgRisposta = null;
  595.             }
  596.         }catch(Exception e){
  597.             setSOAPFault(AbstractErrorGenerator.getIntegrationInternalError(context), logCore,msgDiag, e, "FineGestioneRicezioneContenutiApplicativi");
  598.             return;
  599.         }
  600.         
  601.         
  602.         
  603.         
  604.         
  605.         
  606.         
  607.         
  608.         
  609.         // ------------- Dump risposta in uscita-----------------------------
  610.         if(Dump.isSistemaDumpDisponibile()){
  611.             try{
  612.                 ConfigurazionePdDManager configurazionePdDReader = ConfigurazionePdDManager.getInstance();  
  613.                 if (msgRisposta!=null) {
  614.                     
  615.                     Dump dumpApplicativo = getDump(configurazionePdDReader, protocolFactory, internalObjects, msgDiag.getPorta());
  616.                     if(outResponseContext.getResponseHeaders()==null) {
  617.                         outResponseContext.setResponseHeaders(new HashMap<>());
  618.                     }
  619.                     Map<String, List<String>> propertiesTrasporto = outResponseContext.getResponseHeaders();
  620.                     ServicesUtils.setGovWayHeaderResponse(requestMessage.getServiceBinding(),
  621.                             msgRisposta, OpenSPCoop2Properties.getInstance(),
  622.                             propertiesTrasporto, logCore, true, outResponseContext.getPddContext(), this.msgContext.getRequestInfo());
  623.                     dumpApplicativo.dumpRispostaUscita(msgRisposta, 
  624.                             inRequestContext.getConnettore().getUrlProtocolContext(), 
  625.                             outResponseContext.getResponseHeaders());
  626.                 }
  627.             }catch(DumpException e){
  628.                 setSOAPFault(AbstractErrorGenerator.getIntegrationInternalError(context), logCore,msgDiag, e, "DumpNonRiuscito");
  629.             }catch(Exception e){
  630.                 logError(logCore, e.getMessage(),e);
  631.                 // Se non riesco ad accedere alla configurazione sicuramente gia' nel messaggio di risposta e' presente l'errore di PdD non correttamente inizializzata
  632.             }
  633.         }
  634.         
  635.         
  636.     }
  637.     
  638.     private Dump getDump(ConfigurazionePdDManager configurazionePdDReader,
  639.             IProtocolFactory<?> protocolFactory,
  640.             HashMap<String, Object> internalObjects,
  641.             String nomePorta) throws DumpException, DriverRegistroServiziException {
  642.         
  643.         DumpConfigurazione dumpConfig = null;
  644.         if(internalObjects.containsKey(CostantiPdD.DUMP_CONFIG)) {
  645.             dumpConfig = (DumpConfigurazione) internalObjects.get(CostantiPdD.DUMP_CONFIG); // dovrebbe essere stata impostata per la pd/pa specifica
  646.         }
  647.         else {
  648.             dumpConfig = configurazionePdDReader.getDumpConfigurazionePortaDelegata();
  649.         }
  650.         
  651.         ProtocolContext protocolContext = this.msgContext.getProtocol();
  652.         URLProtocolContext urlProtocolContext = this.msgContext.getUrlProtocolContext();
  653.         IDSoggetto soggettoErogatore = null;
  654.         IDServizio idServizio = null;
  655.         IDSoggetto fruitore = null;
  656.         IDSoggetto dominio = null;
  657.         String idRichiesta = null;
  658.         if(protocolContext!=null) {
  659.             if(protocolContext.getTipoServizio()!=null && protocolContext.getServizio()!=null && protocolContext.getVersioneServizio()!=null &&
  660.                 protocolContext.getErogatore()!=null && protocolContext.getErogatore().getTipo()!=null && protocolContext.getErogatore().getNome()!=null) {
  661.                 idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(protocolContext.getTipoServizio(), protocolContext.getServizio(), 
  662.                         protocolContext.getErogatore(), protocolContext.getVersioneServizio());
  663.             }
  664.             dominio = protocolContext.getDominio();
  665.             idRichiesta = protocolContext.getIdRichiesta();
  666.             if(protocolContext.getFruitore()!=null && protocolContext.getFruitore().getTipo()!=null && protocolContext.getFruitore().getNome()!=null) {
  667.                 fruitore = protocolContext.getFruitore();
  668.             }
  669.         }
  670.         
  671.         if(dominio == null || fruitore==null || idServizio == null) {
  672.             if(urlProtocolContext!=null && urlProtocolContext.getInterfaceName()!=null) {
  673.                 IDPortaDelegata identificativoPortaDelegata = new IDPortaDelegata();
  674.                 identificativoPortaDelegata.setNome(urlProtocolContext.getInterfaceName());
  675.                 PortaDelegata portaDelegata = null;
  676.                 try {
  677.                     portaDelegata = configurazionePdDReader.getPortaDelegataSafeMethod(identificativoPortaDelegata, this.msgContext.getRequestInfo());
  678.                 }catch(Exception e) {
  679.                     // ignore
  680.                 }
  681.                 if(portaDelegata!=null) {
  682.                     // Aggiorno tutti
  683.                     soggettoErogatore = new IDSoggetto(portaDelegata.getSoggettoErogatore().getTipo(),portaDelegata.getSoggettoErogatore().getNome());
  684.                     if(portaDelegata.getServizio()!=null) {
  685.                         idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(portaDelegata.getServizio().getTipo(),portaDelegata.getServizio().getNome(), 
  686.                                     soggettoErogatore, portaDelegata.getServizio().getVersione());
  687.                     }
  688.                     dominio = new IDSoggetto(portaDelegata.getTipoSoggettoProprietario(), portaDelegata.getNomeSoggettoProprietario());
  689.                     fruitore = new IDSoggetto(portaDelegata.getTipoSoggettoProprietario(), portaDelegata.getNomeSoggettoProprietario());
  690.                     try {
  691.                         dominio.setCodicePorta(RegistroServiziManager.getInstance().getDominio(dominio, null, protocolFactory, this.msgContext.getRequestInfo()));
  692.                     }catch(Exception e) {
  693.                         dominio = OpenSPCoop2Properties.getInstance().getIdentitaPortaDefault(protocolFactory.getProtocol(), this.msgContext.getRequestInfo());
  694.                     }
  695.                 }
  696.             }
  697.         }
  698.         if(idServizio!=null) {
  699.             if(protocolContext!=null && protocolContext.getAzione()!=null) {
  700.                 idServizio.setAzione(protocolContext.getAzione());
  701.             }
  702.             else if(this.msgContext.getRequestInfo()!=null && 
  703.                     this.msgContext.getRequestInfo().getIdServizio()!=null && this.msgContext.getRequestInfo().getIdServizio().getAzione()!=null) {
  704.                 idServizio.setAzione(this.msgContext.getRequestInfo().getIdServizio().getAzione());
  705.             }
  706.         }
  707.         if(dominio==null) {
  708.             dominio = OpenSPCoop2Properties.getInstance().getIdentitaPortaDefault(protocolFactory.getProtocol(), this.msgContext.getRequestInfo());
  709.         }

  711.         Dump dumpApplicativo = null;
  712.         if(idServizio!=null){
  713.             dumpApplicativo = new Dump(dominio,
  714.                     this.msgContext.getIdModulo(), 
  715.                     idRichiesta, fruitore, idServizio,
  716.                     this.msgContext.getTipoPorta(), nomePorta, this.msgContext.getPddContext(),
  717.                     null,null,
  718.                     dumpConfig);
  719.         }else{
  720.             dumpApplicativo = new Dump(dominio,
  721.                     this.msgContext.getIdModulo(),this.msgContext.getTipoPorta(), nomePorta,this.msgContext.getPddContext(),
  722.                     null,null,
  723.                     dumpConfig);
  724.         }
  725.         
  726.         return  dumpApplicativo;
  727.     }
  728.     
  729.     private void setSOAPFault(IntegrationFunctionError integrationFunctionError, Logger logCore, MsgDiagnostico msgDiag, Exception e, String posizione){
  730.         
  731.         HandlerException he = null;
  732.         if(e!=null && (e instanceof HandlerException)){
  733.             he = (HandlerException) e;
  734.         }
  735.         
  736.         if(msgDiag!=null){
  737.             if(he!=null){
  738.                 if(he.isEmettiDiagnostico()){
  739.                     msgDiag.logErroreGenerico(e, posizione);
  740.                 }
  741.             }else{
  742.                 msgDiag.logErroreGenerico(e, posizione);
  743.             }
  744.         }
  745.         else {
  746.             if(e!=null) {
  747.                 logError(logCore, posizione+": "+e.getMessage(),e);
  748.             }
  749.             else {
  750.                 logError(logCore, posizione);
  751.             }
  752.         }
  753.         
  754.         IntegrationFunctionError ifError = integrationFunctionError;
  755.         if(he!=null && he.getIntegrationFunctionError()!=null) {
  756.             ifError = he.getIntegrationFunctionError();
  757.         }
  758.         ErroreIntegrazione erroreIntegrazioneGenerato = null;
  759.         if(he!=null){
  760.             erroreIntegrazioneGenerato = he.convertToErroreIntegrazione();
  761.         }
  762.         
  763.         if (this.msgContext.isGestioneRisposta()) {
  764.             String posizioneFault = null;
  765.             if(e!=null) {
  766.                 posizioneFault = posizione+": "+e.getMessage();
  767.             }
  768.             else {
  769.                 posizioneFault = posizione;
  770.             }
  771.             if(erroreIntegrazioneGenerato==null) {
  772.                 erroreIntegrazioneGenerato = ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.get5XX_ErroreProcessamento(posizioneFault);
  773.             }
  774.             OpenSPCoop2Message messageFault = this.generatoreErrore.build(this.msgContext.getPddContext(), ifError, 
  775.                     erroreIntegrazioneGenerato,
  776.                     e, null);
  777.             this.msgContext.setMessageResponse(messageFault);
  778.         }
  779.     }
  780.     
  781.     private boolean checkInizializzazione(Logger logCore, ConfigurazionePdDManager configurazionePdDReader, RegistroServiziManager registroServiziReader,
  782.             PdDContext pddContext) {
  783.         if (!OpenSPCoop2Startup.initialize) {
  784.             String msgErrore = "Inizializzazione di GovWay non correttamente effettuata";
  785.             logError(logCore, "["+ RicezioneContenutiApplicativi.ID_MODULO+ "]  "+msgErrore);
  786.             try{
  787.                 // provo ad emetter un diagnostico
  788.                 if(this.msgContext.getMsgDiagnostico()!=null){
  789.                     this.msgContext.getMsgDiagnostico().logErroreGenerico(msgErrore,"InizializzazioneGovWay");
  790.                 }
  791.             }catch(Throwable t){logError(logCore, "Emissione diagnostico per errore inizializzazione non riuscita: "+t.getMessage(),t);}
  792.             if (this.msgContext.isGestioneRisposta()) {
  793.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext, IntegrationFunctionError.GOVWAY_NOT_INITIALIZED, 
  794.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  795.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_501_PDD_NON_INIZIALIZZATA),null,null)));
  796.             }
  797.             return false;
  798.         }
  799.         if (!TimerMonitoraggioRisorseThread.isRisorseDisponibili()) {
  800.             String msgErrore = "Risorse di sistema non disponibili: "+ TimerMonitoraggioRisorseThread.getRisorsaNonDisponibile().getMessage();
  801.             logError(logCore, "["+ RicezioneContenutiApplicativi.ID_MODULO+ "]  "+msgErrore,TimerMonitoraggioRisorseThread.getRisorsaNonDisponibile());
  802.             try{
  803.                 // provo ad emetter un diagnostico
  804.                 if(this.msgContext.getMsgDiagnostico()!=null){
  805.                     this.msgContext.getMsgDiagnostico().logErroreGenerico(msgErrore,"InizializzazioneRisorseGovWay");
  806.                 }
  807.             }catch(Throwable t){logError(logCore, "Emissione diagnostico per errore inizializzazione non riuscita: "+t.getMessage(),t);}
  808.             if (this.msgContext.isGestioneRisposta()) {
  809.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext, IntegrationFunctionError.GOVWAY_RESOURCES_NOT_AVAILABLE, 
  810.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  811.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_532_RISORSE_NON_DISPONIBILI),null,null)));
  812.             }
  813.             return false;
  814.         }
  815.         if (!TimerThresholdThread.freeSpace) {
  816.             String msgErrore = "Non sono disponibili abbastanza risorse per la gestione della richiesta";
  817.             logError(logCore, "["+ RicezioneContenutiApplicativi.ID_MODULO+ "]  "+msgErrore);
  818.             try{
  819.                 // provo ad emetter un diagnostico
  820.                 if(this.msgContext.getMsgDiagnostico()!=null){
  821.                     this.msgContext.getMsgDiagnostico().logErroreGenerico(msgErrore,"DisponibilitaRisorseGovWay");
  822.                 }
  823.             }catch(Throwable t){logError(logCore, "Emissione diagnostico per errore inizializzazione non riuscita: "+t.getMessage(),t);}
  824.             if (this.msgContext.isGestioneRisposta()) {
  825.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext, IntegrationFunctionError.GOVWAY_RESOURCES_NOT_AVAILABLE, 
  826.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  827.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_533_RISORSE_DISPONIBILI_LIVELLO_CRITICO),null,null)));
  828.             }
  829.             return false;
  830.         }
  831.         if (!Tracciamento.tracciamentoDisponibile) {
  832.             String msgErrore = "Tracciatura non disponibile: "+ Tracciamento.motivoMalfunzionamentoTracciamento.getMessage();
  833.             logError(logCore, "["+ RicezioneContenutiApplicativi.ID_MODULO
  834.                     + "]  "+msgErrore,Tracciamento.motivoMalfunzionamentoTracciamento);
  835.             try{
  836.                 // provo ad emetter un diagnostico
  837.                 if(this.msgContext.getMsgDiagnostico()!=null){
  838.                     this.msgContext.getMsgDiagnostico().logErroreGenerico(msgErrore,"Tracciamento");
  839.                 }
  840.             }catch(Throwable t){logError(logCore, "Emissione diagnostico per errore inizializzazione non riuscita: "+t.getMessage(),t);}
  841.             if (this.msgContext.isGestioneRisposta()) {
  842.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext, IntegrationFunctionError.GOVWAY_RESOURCES_NOT_AVAILABLE, 
  843.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  844.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_545_TRACCIATURA_NON_FUNZIONANTE),null,null)));
  845.             }
  846.             return false;
  847.         }
  848.         if (!MsgDiagnostico.gestoreDiagnosticaDisponibile) {
  849.             String msgErrore = "Sistema di diagnostica non disponibile: "+ MsgDiagnostico.motivoMalfunzionamentoDiagnostici.getMessage();
  850.             logError(logCore, "["+ RicezioneContenutiApplicativi.ID_MODULO
  851.                     + "]  "+msgErrore,MsgDiagnostico.motivoMalfunzionamentoDiagnostici);
  852.             try{
  853.                 // provo ad emetter un diagnostico lo stesso (molto probabilmente non ci riuscirร  essendo proprio la risorsa diagnostica non disponibile)
  854.                 if(this.msgContext.getMsgDiagnostico()!=null){
  855.                     this.msgContext.getMsgDiagnostico().logErroreGenerico(msgErrore,"Diagnostica");
  856.                 }
  857.             }catch(Throwable t){logDebug(logCore, "Emissione diagnostico per errore inizializzazione non riuscita: "+t.getMessage(),t);}
  858.             if (this.msgContext.isGestioneRisposta()) {
  859.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext, IntegrationFunctionError.GOVWAY_RESOURCES_NOT_AVAILABLE, 
  860.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  861.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_546_DIAGNOSTICA_NON_FUNZIONANTE),null,null)));
  862.             }
  863.             return false;
  864.         }
  865.         if (!Dump.isSistemaDumpDisponibile()) {
  866.             String msgErrore = "Sistema di dump dei contenuti applicativi non disponibile: "+ Dump.getMotivoMalfunzionamentoDump().getMessage();
  867.             logError(logCore, "["+ RicezioneContenutiApplicativi.ID_MODULO
  868.                     + "]  "+msgErrore,Dump.getMotivoMalfunzionamentoDump());
  869.             try{
  870.                 // provo ad emetter un diagnostico
  871.                 if(this.msgContext.getMsgDiagnostico()!=null){
  872.                     this.msgContext.getMsgDiagnostico().logErroreGenerico(msgErrore,"Dump");
  873.                 }
  874.             }catch(Throwable t){logError(logCore, "Emissione diagnostico per errore inizializzazione non riuscita: "+t.getMessage(),t);}
  875.             if (this.msgContext.isGestioneRisposta()) {
  876.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext, IntegrationFunctionError.GOVWAY_RESOURCES_NOT_AVAILABLE, 
  877.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  878.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_547_DUMP_CONTENUTI_APPLICATIVI_NON_FUNZIONANTE),null,null)));
  879.             }
  880.             return false;
  881.         }
  882.         // Check Configurazione (XML)
  883.         try{
  884.             configurazionePdDReader.verificaConsistenzaConfigurazione();    
  885.         }catch(Exception e){
  886.             String msgErrore = "Riscontrato errore durante la verifica della consistenza della configurazione";
  887.             logError(logCore, "["+ RicezioneContenutiApplicativi.ID_MODULO
  888.                     + "]  "+msgErrore,e);
  889.             try{
  890.                 // provo ad emetter un diagnostico
  891.                 if(this.msgContext.getMsgDiagnostico()!=null){
  892.                     this.msgContext.getMsgDiagnostico().logErroreGenerico(msgErrore,"CheckConfigurazioneGovWay");
  893.                 }
  894.             }catch(Throwable t){logError(logCore, "Emissione diagnostico per errore inizializzazione non riuscita: "+t.getMessage(),t);}
  895.             if (this.msgContext.isGestioneRisposta()) {
  896.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext, IntegrationFunctionError.GOVWAY_RESOURCES_NOT_AVAILABLE, 
  897.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  898.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE),null,null)));
  899.             }
  900.             return false;
  901.         }
  902.         // Check RegistroServizi (XML)
  903.         try{
  904.             registroServiziReader.verificaConsistenzaRegistroServizi();
  905.         }catch(Exception e){
  906.             String msgErrore = "Riscontrato errore durante la verifica del registro dei servizi";
  907.             logError(logCore, "["+ RicezioneContenutiApplicativi.ID_MODULO
  908.                     + "]  "+msgErrore,e);
  909.             try{
  910.                 // provo ad emetter un diagnostico
  911.                 if(this.msgContext.getMsgDiagnostico()!=null){
  912.                     this.msgContext.getMsgDiagnostico().logErroreGenerico(msgErrore,"CheckRegistroServizi");
  913.                 }
  914.             }catch(Throwable t){logError(logCore, "Emissione diagnostico per errore inizializzazione non riuscita: "+t.getMessage(),t);}
  915.             if (this.msgContext.isGestioneRisposta()) {
  916.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext, IntegrationFunctionError.GOVWAY_RESOURCES_NOT_AVAILABLE, 
  917.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  918.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_534_REGISTRO_DEI_SERVIZI_NON_DISPONIBILE),null,null)));
  919.             }
  920.             return false;
  921.         }
  922.         
  923.         return true;
  924.     }

  926.     private void process_engine(InRequestContext inRequestContext,HashMap<String, Object> internalObjects,Object ... params) 
  927.             throws TracciamentoException, DumpException, ProtocolException {

  929.     
  930.         
  931.         /* ------------ Lettura parametri della richiesta ------------- */

  933.         // Messaggio di ingresso
  934.         OpenSPCoop2Message requestMessage = inRequestContext.getMessaggio();
  935.                 
  936.         // Logger
  937.         Logger logCore = inRequestContext.getLogCore();
  938.         
  939.         // Data Ingresso Richiesta
  940.         Date dataIngressoRichiesta = this.msgContext.getDataIngressoRichiesta();
  941.         
  942.         // ID Transazione
  943.         String idTransazione = PdDContext.getValue(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, inRequestContext.getPddContext());
  944.         
  945.         // RequestInfo
  946.         RequestInfo requestInfo = this.msgContext.getRequestInfo();
  947.         
  948.         // Parametri della porta delegata invocata
  949.         URLProtocolContext urlProtocolContext = this.msgContext.getUrlProtocolContext();

  951.         // Credenziali utilizzate nella richiesta
  952.         Credenziali credenziali = this.msgContext.getCredenziali();

  954.         // Autenticazione/Autorizzazione registrate
  955.         ClassNameProperties className = ClassNameProperties.getInstance();

  957.         // PropertiesReader
  958.         OpenSPCoop2Properties propertiesReader = OpenSPCoop2Properties.getInstance();
  959.         PdDContext pddContext = inRequestContext.getPddContext();
  960.         if (propertiesReader == null) {
  961.             String msg = "Inizializzazione di GovWay non correttamente effettuata: OpenSPCoopProperties";
  962.             logError(logCore, msg);
  963.             if (this.msgContext.isGestioneRisposta()) {
  964.                 this.msgContext.setMessageResponse(this.generatoreErrore.build(pddContext, IntegrationFunctionError.GOVWAY_NOT_INITIALIZED, 
  965.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  966.                         get5XX_ErroreProcessamento(msg,CodiceErroreIntegrazione.CODICE_501_PDD_NON_INIZIALIZZATA), null, null));
  967.             }
  968.             return;
  969.         }

  971.         // Configurazione PdD Reader
  972.         ConfigurazionePdDManager configurazionePdDReader = ConfigurazionePdDManager.getInstance();

  974.         // RegistroServizi Reader
  975.         RegistroServiziManager registroServiziReader = RegistroServiziManager.getInstance();

  977.         if(requestInfo==null) {
  978.             String msg = "Inizializzazione di GovWay non correttamente effettuata: RequestInfo is null";
  979.             logError(logCore, msg);
  980.             if (this.msgContext.isGestioneRisposta()) {
  981.                 this.msgContext.setMessageResponse(this.generatoreErrore.build(pddContext, IntegrationFunctionError.INTERNAL_REQUEST_ERROR, 
  982.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  983.                         get5XX_ErroreProcessamento(msg), null, null));
  984.             }
  985.             return;
  986.         }
  987.         
  988.         // IdentificativoPdD
  989.         IDSoggetto identitaPdD = requestInfo.getIdentitaPdD();

  991.         // ProtocolFactory
  992.         IProtocolFactory<?> protocolFactory = requestInfo.getProtocolFactory();
  993.         ITraduttore traduttore = protocolFactory.createTraduttore();
  994.         IProtocolManager protocolManager = protocolFactory.createProtocolManager();
  995.         IProtocolConfiguration protocolConfig = protocolFactory.createProtocolConfiguration();
  996.         
  997.         // ProprietaErroreApplicativo
  998.         ProprietaErroreApplicativo proprietaErroreAppl = propertiesReader
  999.                 .getProprietaGestioneErrorePD(protocolManager);
  1000.         proprietaErroreAppl.setDominio(identitaPdD.getCodicePorta());
  1001.         proprietaErroreAppl.setIdModulo(this.msgContext.getIdModulo());
  1002.         if(this.msgContext.isForceFaultAsXML()){
  1003.             proprietaErroreAppl.setFaultAsXML(true); // es. se siamo in una richiesta http senza SOAP, un SoapFault non ha senso
  1004.         }
  1005.         this.msgContext.setProprietaErroreAppl(proprietaErroreAppl);
  1006.         this.generatoreErrore.updateProprietaErroreApplicativo(proprietaErroreAppl);
  1007.                 
  1008.         // MESSAGGIO DI LIBRERIA
  1009.         ImbustamentoMessage imbustamentoMSG = new ImbustamentoMessage();
  1010.         
  1011.         // Context di risposta
  1012.         this.msgContext.setProtocol(new ProtocolContext());
  1013.         this.msgContext.getProtocol().setDominio(this.msgContext.getIdentitaPdD());
  1014.         this.msgContext.setIntegrazione(new IntegrationContext());

  1016.         
  1017.         
  1018.         
  1019.         
  1020.         
  1021.         /* ------------ Controllo inizializzazione OpenSPCoop ------------------ */
  1022.         if(!checkInizializzazione(logCore, configurazionePdDReader, registroServiziReader, pddContext)) {
  1023.             return;
  1024.         }
  1025.         
  1026.         
  1027.         
  1028.         // Logger dei messaggi diagnostici
  1029.         String nomePorta = null;
  1030.         if(requestInfo.getProtocolContext().getInterfaceName()!=null){
  1031.             nomePorta = requestInfo.getProtocolContext().getInterfaceName();
  1032.         }
  1033.         else{
  1034.             nomePorta = urlProtocolContext.getFunctionParameters() + "_urlInvocazione("+ urlProtocolContext.getUrlInvocazione_formBased() + ")";
  1035.         }
  1036.         MsgDiagnostico msgDiag = MsgDiagnostico.newInstance(TipoPdD.DELEGATA,identitaPdD, this.msgContext.getIdModulo(),nomePorta,requestInfo,configurazionePdDReader);
  1037.         if(msgDiag==null) {
  1038.             String msg = "Inizializzazione di GovWay non correttamente effettuata: MsgDiagnostico is null";
  1039.             logError(logCore, msg);
  1040.             if (this.msgContext.isGestioneRisposta()) {
  1041.                 this.msgContext.setMessageResponse(this.generatoreErrore.build(pddContext, IntegrationFunctionError.GOVWAY_NOT_INITIALIZED, 
  1042.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1043.                         get5XX_ErroreProcessamento(msg,CodiceErroreIntegrazione.CODICE_501_PDD_NON_INIZIALIZZATA), null, null));
  1044.             }
  1045.             return;
  1046.         }
  1047.         this.msgContext.setMsgDiagnostico(msgDiag); // aggiorno msg diagnostico
  1048.         msgDiag.setPddContext(inRequestContext.getPddContext(), protocolFactory);
  1049.         msgDiag.setPrefixMsgPersonalizzati(MsgDiagnosticiProperties.MSG_DIAG_RICEZIONE_CONTENUTI_APPLICATIVI);
  1050.         

  1052.         // set credenziali
  1053.         setCredenziali(credenziali, msgDiag);

  1055.         // inizializzazione risorse statiche
  1056.         try {
  1057.             if (RicezioneContenutiApplicativi.initializeService == false) {
  1058.                 msgDiag.mediumDebug("Inizializzazione risorse statiche...");
  1059.                 RicezioneContenutiApplicativi.initializeService(configurazionePdDReader,className,propertiesReader, logCore);
  1060.             }
  1061.         } catch (Exception e) {
  1062.             msgDiag.logErroreGenerico(e,"InizializzazioneRisorseServizioRicezioneContenutiApplicativi");
  1063.             if (this.msgContext.isGestioneRisposta()) {
  1064.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext, IntegrationFunctionError.GOVWAY_NOT_INITIALIZED, 
  1065.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1066.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_501_PDD_NON_INIZIALIZZATA),e,null)));
  1067.             }
  1068.             return;
  1069.         }

  1071.         // Loader classi dinamiche
  1072.         Loader loader = Loader.getInstance();
  1073.         PddPluginLoader pluginLoader = PddPluginLoader.getInstance();
  1074.         
  1075.         // ConnectorInMessage
  1076.         @SuppressWarnings("unused")
  1077.         ConnectorInMessage connectorInMessage = null;
  1078.         if(params!=null){
  1079.             for (int i = 0; i < params.length; i++) {
  1080.                 if(params[i]!=null && (params[i] instanceof ConnectorInMessage) ){
  1081.                     connectorInMessage = (ConnectorInMessage) params[i];
  1082.                     break;
  1083.                 }
  1084.             }
  1085.         }
  1086.         
  1087.         Transaction transaction = null;
  1088.         try{
  1089.             transaction = TransactionContext.getTransaction(idTransazione);
  1090.         }catch(Exception e){
  1091.             msgDiag.logErroreGenerico(e,"getTransaction");
  1092.             if (this.msgContext.isGestioneRisposta()) {
  1093.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext, IntegrationFunctionError.INTERNAL_REQUEST_ERROR, 
  1094.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1095.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_500_ERRORE_INTERNO),e,null)));
  1096.             }
  1097.             return;
  1098.         }
  1099.         
  1100.         
  1101.         

  1103.         // --------- OPENSPCOOPSTATE ---------
  1104.         OpenSPCoopState openspcoopstate = null;
  1105.         try{ // finally in fondo, vedi  #try-finally-openspcoopstate#
  1106.             
  1107.         msgDiag.mediumDebug("Inizializzazione connessione al database...");
  1108.         try {
  1109.             openspcoopstate = new OpenSPCoopStateful();
  1110.             openspcoopstate.setUseConnection(false); // gestione stateless per default
  1111.             openspcoopstate.initResource(identitaPdD, this.msgContext.getIdModulo(), idTransazione);
  1112.         } catch (Exception e) {
  1113.             msgDiag.logErroreGenerico(e,"openspcoopstate.initResource()");
  1114.             openspcoopstate.releaseResource();
  1115.             if (this.msgContext.isGestioneRisposta()) {
  1116.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.GOVWAY_RESOURCES_NOT_AVAILABLE, 
  1117.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1118.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_505_GET_DB_CONNECTION), e,null)));
  1119.             }
  1120.             return;
  1121.         }
  1122.         
  1123.         // Refresh reader
  1124.         registroServiziReader = registroServiziReader.refreshState(openspcoopstate.getStatoRichiesta(),openspcoopstate.getStatoRisposta());
  1125.         configurazionePdDReader = configurazionePdDReader.refreshState(registroServiziReader);
  1126.         msgDiag.updateState(configurazionePdDReader);
  1127.         
  1128.         
  1129.         
  1130.         
  1131.         

  1133.         
  1134.         

  1136.         
  1137.         
  1138.         Utilities.printFreeMemory("RicezioneContenutiApplicativi - Identificazione porta delegata e soggetto fruitore...");
  1139.         
  1140.         /* ------------ Identificazione Porta Delegata e SoggettoFruitore */
  1141.         msgDiag.mediumDebug("Identificazione porta delegata e soggetto fruitore...");
  1142.         IDPortaDelegata identificativoPortaDelegata = null;
  1143.         PortaDelegata portaDelegata = null;
  1144.         String nomeUtilizzatoPerErrore = null;
  1145.         try {
  1146.             if(urlProtocolContext.getInterfaceName()!=null) {
  1147.                 identificativoPortaDelegata = new IDPortaDelegata();
  1148.                 identificativoPortaDelegata.setNome(urlProtocolContext.getInterfaceName());
  1149.                 portaDelegata = configurazionePdDReader.getPortaDelegata(identificativoPortaDelegata, requestInfo);
  1150.                 nomeUtilizzatoPerErrore = identificativoPortaDelegata.getNome();
  1151.             }
  1152.             else {
  1153.                 throw new Exception("InterfaceName non presente");
  1154.             }
  1155.         } catch (Exception e) {
  1156.             msgDiag.logErroreGenerico(e,"getPorta");
  1157.             openspcoopstate.releaseResource();
  1158.             if (this.msgContext.isGestioneRisposta()) {
  1159.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_REQUEST_ERROR, 
  1160.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1161.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_502_IDENTIFICAZIONE_PORTA), e,null)));
  1162.             }
  1163.             return;
  1164.         }

  1166.         // Raccolgo dati
  1167.         IDSoggetto soggettoFruitore = null;
  1168.         try {
  1169.             if(portaDelegata!=null) {
  1170.                 soggettoFruitore = new IDSoggetto(portaDelegata.getTipoSoggettoProprietario(), portaDelegata.getNomeSoggettoProprietario());
  1171.                 soggettoFruitore.setCodicePorta(configurazionePdDReader.getIdentificativoPorta(soggettoFruitore, protocolFactory, requestInfo));
  1172.             }
  1173.         } catch (Exception e) {
  1174.             msgDiag.logErroreGenerico(e,"getIdentificativoPorta");
  1175.             openspcoopstate.releaseResource();
  1176.             if (this.msgContext.isGestioneRisposta()) {
  1177.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_REQUEST_ERROR, 
  1178.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1179.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_502_IDENTIFICAZIONE_PORTA), e,null)));
  1180.             }
  1181.             return;
  1182.         }
  1183.         if(identificativoPortaDelegata.getIdentificativiFruizione()==null) {
  1184.             identificativoPortaDelegata.setIdentificativiFruizione(new IdentificativiFruizione());
  1185.         }
  1186.         identificativoPortaDelegata.getIdentificativiFruizione().setSoggettoFruitore(soggettoFruitore);
  1187.         if(soggettoFruitore!=null) {
  1188.             identitaPdD = soggettoFruitore; // la PdD Assume l'identita del soggetto
  1189.         }
  1190.         this.msgContext.getProtocol().setDominio(identitaPdD);
  1191.         this.msgContext.setIdentitaPdD(identitaPdD);
  1192.         // che possiede la Porta Delegata ID Porta Delegata
  1193.         this.msgContext.getIntegrazione().setIdPD(identificativoPortaDelegata);
  1194.         // altri contesti
  1195.         msgDiag.setDominio(identitaPdD); // imposto anche il dominio nel msgDiag
  1196.         msgDiag.setFruitore(soggettoFruitore);
  1197.         msgDiag.addKeyword(CostantiPdD.KEY_PORTA_DELEGATA, identificativoPortaDelegata.getNome());
  1198.         msgDiag.addKeywords(soggettoFruitore);
  1199.         proprietaErroreAppl.setDominio(identitaPdD.getCodicePorta()); // imposto
  1200.         // requestInfo
  1201.         requestInfo.setIdentitaPdD(identitaPdD);
  1202.         // anche il dominio per gli errori
  1203.         this.msgContext.setProprietaErroreAppl(proprietaErroreAppl);
  1204.         // GeneratoreErrore
  1205.         this.generatoreErrore.updateDominio(identitaPdD);
  1206.         this.generatoreErrore.updateProprietaErroreApplicativo(proprietaErroreAppl);
  1207.     
  1208.         
  1209.         
  1210.         
  1211.         
  1212.         

  1214.         
  1215.         
  1216.         
  1217.         
  1218.         
  1219.         
  1220.         
  1221.         
  1222.         
  1223.         
  1224.         Utilities.printFreeMemory("RicezioneContenutiApplicativi - Lettura header di integrazione...");
  1225.         

  1227.         /* --------------- Header Integrazione --------------- */
  1228.         msgDiag.mediumDebug("Lettura header di integrazione...");
  1229.         HeaderIntegrazione headerIntegrazioneRichiesta = null;
  1230.         if (this.msgContext.getHeaderIntegrazioneRichiesta() != null)
  1231.             headerIntegrazioneRichiesta = this.msgContext.getHeaderIntegrazioneRichiesta(); // prendo quello dell'IntegrationManager
  1232.         else
  1233.             headerIntegrazioneRichiesta = new HeaderIntegrazione(idTransazione);
  1234.         HeaderIntegrazione headerIntegrazioneRisposta = null;
  1235.         String[] tipiIntegrazionePD = null;
  1236.         try {
  1237.             tipiIntegrazionePD = configurazionePdDReader.getTipiIntegrazione(portaDelegata);
  1238.         } catch (Exception e) {
  1239.             msgDiag.logErroreGenerico(e, "getTipiIntegrazione(pd)");
  1240.             openspcoopstate.releaseResource();
  1241.             if (this.msgContext.isGestioneRisposta()) {
  1242.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_REQUEST_ERROR, 
  1243.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1244.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE), e,null)));
  1245.             }
  1246.             return;
  1247.         }
  1248.         if (tipiIntegrazionePD == null){
  1249.             if(RicezioneContenutiApplicativi.defaultPerProtocolloGestoreIntegrazionePD.containsKey(protocolFactory.getProtocol()))
  1250.                 tipiIntegrazionePD = RicezioneContenutiApplicativi.defaultPerProtocolloGestoreIntegrazionePD.get(protocolFactory.getProtocol());
  1251.             else
  1252.                 tipiIntegrazionePD = RicezioneContenutiApplicativi.defaultGestoriIntegrazionePD;
  1253.         }

  1255.         InRequestPDMessage inRequestPDMessage = new InRequestPDMessage();
  1256.         inRequestPDMessage.setBustaRichiesta(null); // non lo si conosce l'aggiorno appena letto le informazioni dal registro
  1257.         inRequestPDMessage.setMessage(requestMessage);
  1258.         inRequestPDMessage.setUrlProtocolContext(this.msgContext.getUrlProtocolContext());
  1259.         inRequestPDMessage.setPortaDelegata(portaDelegata);
  1260.         inRequestPDMessage.setSoggettoPropeprietarioPortaDelegata(soggettoFruitore);
  1261.         for (int i = 0; i < tipiIntegrazionePD.length; i++) {
  1262.             try {
  1263.                 
  1264.                 IGestoreIntegrazionePD gestore = null;
  1265.                 try {
  1266.                     gestore = (IGestoreIntegrazionePD) pluginLoader.newIntegrazionePortaDelegata(tipiIntegrazionePD[i]);
  1267.                 }catch(Exception e){
  1268.                     throw e;
  1269.                 }
  1270.                 if(gestore!=null){
  1271.                     String classType = null;
  1272.                     try {
  1273.                         classType = gestore.getClass().getName();
  1274.                         AbstractCore.init(gestore, pddContext, protocolFactory);
  1275.                     } catch (Exception e) {
  1276.                         throw new Exception(
  1277.                                 "Riscontrato errore durante l'inizializzazione della classe ["+ classType
  1278.                                         + "] da utilizzare per la gestione dell'integrazione delle fruizioni di tipo ["+ tipiIntegrazionePD[i] + "]: " + e.getMessage());
  1279.                     }
  1280.                     gestore.readInRequestHeader(headerIntegrazioneRichiesta,inRequestPDMessage);
  1281.                 }  else {
  1282.                     msgDiag.logErroreGenerico("Lettura Gestore header di integrazione ["
  1283.                                     + tipiIntegrazionePD[i]+ "]  non riuscita: non inizializzato", 
  1284.                                     "gestoriIntegrazionePD.get("+tipiIntegrazionePD[i]+")");
  1285.                 }
  1286.             } catch (Exception e) {
  1287.                 logDebug(logCore, "Errore durante la lettura dell'header di integrazione ["+ tipiIntegrazionePD[i]
  1288.                                 + "]: "+ e.getMessage(),e);
  1289.                 msgDiag.addKeyword(CostantiPdD.KEY_TIPO_HEADER_INTEGRAZIONE,tipiIntegrazionePD[i]);
  1290.                 msgDiag.addKeywordErroreProcessamento(e);
  1291.                 msgDiag.logPersonalizzato("headerIntegrazione.letturaFallita");
  1292.             }
  1293.         }


  1296.         
  1297.         

  1299.         
  1300.         
  1301.         
  1302.         Utilities.printFreeMemory("RicezioneContenutiApplicativi - Raccolta dati Gestione CORS ...");
  1303.         // NOTA: i dati CORS sono memorizzati solamente nella porta principale e non in quelle di eventuali azioni delegate.
  1304.         //       deve quindi essere recuperata prima di sostituire la pd con una piรน specifica
  1305.         CorsConfigurazione cors = null;
  1306.         HttpServletRequest httpServletRequest = null;
  1307.         boolean effettuareGestioneCORS = false;
  1308.         try {
  1309.             if(requestInfo!=null && requestInfo.getProtocolContext()!=null) {
  1310.                 httpServletRequest = requestInfo.getProtocolContext().getHttpServletRequest();  
  1311.             }
  1312.             
  1313.             if(httpServletRequest!=null && HttpRequestMethod.OPTIONS.name().equalsIgnoreCase(httpServletRequest.getMethod())) {
  1314.                 
  1315.                 Object nomePortaObject = pddContext.getObject(CostantiPdD.NOME_PORTA_INVOCATA);
  1316.                 String nomePortaS = null;
  1317.                 if(nomePortaObject instanceof String) {
  1318.                     nomePortaS = (String) nomePortaObject;
  1319.                 }
  1320.                 PortaDelegata pdDefault = null;
  1321.                 if(nomePortaS!=null) {
  1322.                     IDPortaDelegata idPDdefault = new IDPortaDelegata();
  1323.                     idPDdefault.setNome(nomePortaS);
  1324.                     pdDefault = configurazionePdDReader.getPortaDelegataSafeMethod(idPDdefault, requestInfo);
  1325.                 }
  1326.                 if(pdDefault!=null) {
  1327.                     cors = configurazionePdDReader.getConfigurazioneCORS(pdDefault);
  1328.                 }
  1329.                 else if(portaDelegata!=null) {
  1330.                     cors = configurazionePdDReader.getConfigurazioneCORS(portaDelegata);
  1331.                 }
  1332.                 else {
  1333.                     cors = configurazionePdDReader.getConfigurazioneCORS();
  1334.                 }
  1335.             }
  1336.             else {
  1337.                 cors = new CorsConfigurazione();
  1338.                 cors.setStato(StatoFunzionalita.DISABILITATO);
  1339.             }
  1340.         } catch (Exception e) {
  1341.             msgDiag.logErroreGenerico(e, "configurazionePdDReader.getConfigurazioneCORS(pd)");
  1342.             openspcoopstate.releaseResource();
  1343.             if (this.msgContext.isGestioneRisposta()) {
  1344.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_REQUEST_ERROR, 
  1345.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1346.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE), e,null)));
  1347.             }
  1348.             return;
  1349.         }
  1350.         
  1351.         
  1352.         
  1353.         
  1354.         
  1355.         
  1356.         
  1357.         
  1358.         
  1359.         
  1360.         
  1361.         
  1362.         
  1363.         Utilities.printFreeMemory("RicezioneContenutiApplicativi - Lettura servizio associato alla PD invocata...");
  1364.         
  1365.         
  1366.         

  1368.         /*
  1369.          * ------------- Lettura azione associato alla PD invocata ed eventuale aggiornamento della pd utilizzata ------------
  1370.          */
  1371.         msgDiag.mediumDebug("Lettura azione associato alla PD invocata...");
  1372.         String idModuloInAttesa = null;
  1373.         if (this.msgContext.isGestioneRisposta())
  1374.             idModuloInAttesa = this.msgContext.getIdModulo();
  1375.         RichiestaDelegata richiestaDelegata = new RichiestaDelegata(
  1376.                 identificativoPortaDelegata, null,
  1377.                 idModuloInAttesa, proprietaErroreAppl, identitaPdD);
  1378.         richiestaDelegata.setIntegrazione(this.msgContext.getIntegrazione());
  1379.         richiestaDelegata.setProtocol(this.msgContext.getProtocol());
  1380.         IDServizio idServizio = null;
  1381.         try {
  1382.             if(portaDelegata==null) {
  1383.                 throw new Exception("PortaDelgata non trovata");
  1384.             }
  1385.             IDSoggetto soggettoErogatore = new IDSoggetto(portaDelegata.getSoggettoErogatore().getTipo(),portaDelegata.getSoggettoErogatore().getNome());
  1386.             idServizio = IDServizioFactory.getInstance().getIDServizioFromValues(portaDelegata.getServizio().getTipo(),portaDelegata.getServizio().getNome(), 
  1387.                     soggettoErogatore, portaDelegata.getServizio().getVersione());
  1388.             if(requestInfo.getIdServizio()!=null && requestInfo.getIdServizio().getAzione()!=null){
  1389.                 // gia identificata
  1390.                 idServizio.setAzione(requestInfo.getIdServizio().getAzione());
  1391.                 // aggiorno anche codice porta erogatore gia' identificato
  1392.                 if(requestInfo.getIdServizio().getSoggettoErogatore()!=null) {
  1393.                     idServizio.getSoggettoErogatore().setCodicePorta(requestInfo.getIdServizio().getSoggettoErogatore().getCodicePorta());
  1394.                 }
  1395.             }
  1396.             else{
  1397.                 idServizio.setAzione(configurazionePdDReader.getAzione(portaDelegata, urlProtocolContext, requestInfo, requestMessage, null,
  1398.                         headerIntegrazioneRichiesta, this.msgContext.getIdModulo().endsWith(IntegrationManager.ID_MODULO), protocolFactory));
  1399.             }

  1401.         } catch (IdentificazioneDinamicaException e) {
  1402.             
  1403.             boolean throwFault = true;
  1404.             if(StatoFunzionalita.ABILITATO.equals(cors.getStato()) && this.msgContext.isGestioneRisposta()) {
  1405.                 throwFault = false;
  1406.             }
  1407.             if(throwFault) {
  1408.             
  1409.                 pddContext.addObject(org.openspcoop2.core.constants.Costanti.OPERAZIONE_NON_INDIVIDUATA, "true");
  1410.                 
  1411.                 msgDiag.addKeywordErroreProcessamento(e);
  1412.                 msgDiag.logPersonalizzato("identificazioneDinamicaAzioneNonRiuscita");
  1413.                 openspcoopstate.releaseResource();
  1414.                 if (this.msgContext.isGestioneRisposta()) {
  1415.                     this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.OPERATION_UNDEFINED,
  1416.                             ErroriIntegrazione.ERRORE_403_AZIONE_NON_IDENTIFICATA.getErroreIntegrazione(),e,null)));
  1417.                 }
  1418.                 return;
  1419.             }
  1420.             else {
  1421.                 effettuareGestioneCORS = true;
  1422.             }
  1423.                 
  1424.         } catch (Exception e) {
  1425.             msgDiag.addKeywordErroreProcessamento(e);
  1426.             msgDiag.logPersonalizzato("identificazioneDinamicaAzioneNonRiuscita");
  1427.             logError(logCore, msgDiag.getMessaggio_replaceKeywords("identificazioneDinamicaAzioneNonRiuscita"),e);
  1428.             openspcoopstate.releaseResource();
  1429.             if (this.msgContext.isGestioneRisposta()) {
  1430.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_REQUEST_ERROR,
  1431.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1432.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE), e,null)));
  1433.             }
  1434.             return;
  1435.         }
  1436.         try {
  1437.             if(idServizio!=null && idServizio.getSoggettoErogatore()!=null &&
  1438.                     idServizio.getSoggettoErogatore().getCodicePorta()==null) {
  1439.                 idServizio.getSoggettoErogatore().setCodicePorta(registroServiziReader.getDominio(idServizio.getSoggettoErogatore(), null, protocolFactory, requestInfo));
  1440.             }
  1441.                         
  1442.             // aggiorno idServizio
  1443.             richiestaDelegata.setIdServizio(idServizio);
  1444.             if(identificativoPortaDelegata.getIdentificativiFruizione()!=null) {
  1445.                 identificativoPortaDelegata.getIdentificativiFruizione().setIdServizio(idServizio);
  1446.             }
  1447.         
  1448.             // aggiorno informazioni dell'header di integrazione della risposta
  1449.             headerIntegrazioneRisposta = new HeaderIntegrazione(idTransazione);
  1450.             if(soggettoFruitore!=null) {
  1451.                 headerIntegrazioneRisposta.getBusta().setTipoMittente(soggettoFruitore.getTipo());
  1452.                 headerIntegrazioneRisposta.getBusta().setMittente(soggettoFruitore.getNome());
  1453.             }
  1454.             headerIntegrazioneRisposta.getBusta().setTipoDestinatario(richiestaDelegata.getIdServizio().getSoggettoErogatore().getTipo());
  1455.             headerIntegrazioneRisposta.getBusta().setDestinatario(richiestaDelegata.getIdServizio().getSoggettoErogatore().getNome());
  1456.             headerIntegrazioneRisposta.getBusta().setTipoServizio(richiestaDelegata.getIdServizio().getTipo());
  1457.             headerIntegrazioneRisposta.getBusta().setServizio(richiestaDelegata.getIdServizio().getNome());
  1458.             headerIntegrazioneRisposta.getBusta().setVersioneServizio(richiestaDelegata.getIdServizio().getVersione());
  1459.             headerIntegrazioneRisposta.getBusta().setAzione(richiestaDelegata.getIdServizio().getAzione());
  1460.             if (headerIntegrazioneRichiesta!=null && headerIntegrazioneRichiesta.getBusta() != null
  1461.                     && headerIntegrazioneRichiesta.getBusta().getRiferimentoMessaggio() != null) {
  1462.                 // per profilo asincrono asimmetrico e simmetrico
  1463.                 headerIntegrazioneRisposta.getBusta().setRiferimentoMessaggio(headerIntegrazioneRichiesta.getBusta().getRiferimentoMessaggio());
  1464.             }
  1465.         } catch (Exception e) {
  1466.             msgDiag.logErroreGenerico(e, "configurazionePdDReader.letturaDatiServizioServizioNonRiuscita(pd)");
  1467.             openspcoopstate.releaseResource();
  1468.             if (this.msgContext.isGestioneRisposta()) {
  1469.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_REQUEST_ERROR,
  1470.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1471.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE), e,null)));
  1472.             }
  1473.             return;
  1474.         }
  1475.         msgDiag.setServizio(richiestaDelegata.getIdServizio());
  1476.         msgDiag.addKeywords(richiestaDelegata.getIdServizio());
  1477.         
  1478.         
  1479.         
  1480.         
  1481.         
  1482.         // Gestione CORS
  1483.         
  1484.         if(!effettuareGestioneCORS && StatoFunzionalita.ABILITATO.equals(cors.getStato()) &&
  1485.                 richiestaDelegata!=null && richiestaDelegata.getIdServizio()!=null &&
  1486.                 richiestaDelegata.getIdServizio().getAzione()==null) {
  1487.             if(ServiceBinding.REST.equals(requestInfo.getIntegrationServiceBinding())) {
  1488.                 // in rest una risorsa deve essere riconsociuta
  1489.                 if(StatoFunzionalita.ABILITATO.equals(cors.getStato()) && this.msgContext.isGestioneRisposta()) {
  1490.                     effettuareGestioneCORS = true;
  1491.                 }
  1492.             }
  1493.             else {
  1494.                 boolean azioneErrata = false;
  1495.                 Servizio infoServizio = null;
  1496.                 try {
  1497.                     infoServizio = registroServiziReader.getInfoServizio(soggettoFruitore, richiestaDelegata.getIdServizio(),null,false, true, requestInfo);
  1498.                 } catch (DriverRegistroServiziAzioneNotFound e) {
  1499.                     azioneErrata = true;
  1500.                 } catch (Throwable e) {
  1501.                     // ignore
  1502.                 }
  1503.                 if (infoServizio == null) {
  1504.                     try {
  1505.                         infoServizio = registroServiziReader.getInfoServizioCorrelato(soggettoFruitore,richiestaDelegata.getIdServizio(),null, true, requestInfo);
  1506.                     } catch (DriverRegistroServiziAzioneNotFound e) {
  1507.                         azioneErrata = true;
  1508.                     } catch (Throwable e) {
  1509.                         // ignore
  1510.                     }
  1511.                 }
  1512.                 if(azioneErrata) {
  1513.                     effettuareGestioneCORS = true;
  1514.                 }
  1515.             }
  1516.         }
  1517.         
  1518.         boolean corsTrasparente = false;
  1519.                 
  1520.         if(!effettuareGestioneCORS) {
  1521.             if(pddContext.containsKey(CostantiPdD.CORS_PREFLIGHT_REQUEST_SOAP)) {
  1522.                 effettuareGestioneCORS = true;
  1523.             }
  1524.             else {
  1525.                 // devo verificare se si tratta di una azione matched poichรจ รจ stato inserito un tipo http method 'qualsiasi'
  1526.                 if(propertiesReader.isGestioneCORS_resourceHttpMethodQualsiasi_ricezioneContenutiApplicativi()) {
  1527.                     if(cors!=null && 
  1528.                             StatoFunzionalita.ABILITATO.equals(cors.getStato()) &&
  1529.                             TipoGestioneCORS.GATEWAY.equals(cors.getTipo()) &&
  1530.                             this.msgContext.isGestioneRisposta()) {
  1531.                         if(idServizio!=null && idServizio.getAzione()!=null) {
  1532.                             try {
  1533.                                 RegistroServiziManager registroServiziManager = RegistroServiziManager.getInstance();
  1534.                                 AccordoServizioParteSpecifica asps = registroServiziManager.getAccordoServizioParteSpecifica(idServizio, null, false, requestInfo);
  1535.                                 if(asps!=null) {
  1536.                                     AccordoServizioParteComune aspc = registroServiziManager.getAccordoServizioParteComune(IDAccordoFactory.getInstance().getIDAccordoFromUri(asps.getAccordoServizioParteComune()), null, false, false, requestInfo);
  1537.                                     if(aspc!=null && org.openspcoop2.core.registry.constants.ServiceBinding.REST.equals(aspc.getServiceBinding())) {
  1538.                                         if(aspc.sizeResourceList()>0) {
  1539.                                             for (Resource resource : aspc.getResourceList()) {
  1540.                                                 if(idServizio.getAzione().equals(resource.getNome())) {
  1541.                                                     if(resource.getMethod()==null){
  1542.                                                         effettuareGestioneCORS = true;
  1543.                                                     }
  1544.                                                     break;
  1545.                                                 }
  1546.                                             }
  1547.                                         }
  1548.                                     }
  1549.                                 }
  1550.                             }catch(Throwable tIgnore) {
  1551.                                 // ignore
  1552.                             }
  1553.                         }
  1554.                     }
  1555.                 }
  1556.             }
  1557.         }
  1558.         
  1559.         if(effettuareGestioneCORS) {
  1560.             
  1561.             if(TipoGestioneCORS.GATEWAY.equals(cors.getTipo())) {
  1562.                 
  1563.                 CORSFilter corsFilter = new CORSFilter(logCore, cors);
  1564.                 try {
  1565.                     CORSWrappedHttpServletResponse res = new CORSWrappedHttpServletResponse(false);
  1566.                     corsFilter.doCORS(httpServletRequest, res, CORSRequestType.PRE_FLIGHT, true);
  1567.                     if(this.msgContext.getResponseHeaders()==null) {
  1568.                         this.msgContext.setResponseHeaders(new HashMap<>());
  1569.                     }
  1570.                     this.msgContext.getResponseHeaders().putAll(res.getHeadersValues());
  1571.                     this.msgContext.setMessageResponse(res.buildMessage());
  1572.                     pddContext.addObject(org.openspcoop2.core.constants.Costanti.CORS_PREFLIGHT_REQUEST_VIA_GATEWAY, "true");
  1573.                 }catch(Exception e) {
  1574.                     // un eccezione non dovrebbe succedere
  1575.                     msgDiag.logErroreGenerico(e, "gestioneCORS(pd)");
  1576.                     openspcoopstate.releaseResource();
  1577.                     if (this.msgContext.isGestioneRisposta()) {
  1578.                         this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_REQUEST_ERROR, 
  1579.                                 ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1580.                                 get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE), e,null)));
  1581.                     }
  1582.                     return;
  1583.                 }
  1584.                 
  1585.                 openspcoopstate.releaseResource();
  1586.                 return;
  1587.                     
  1588.             }
  1589.             else {
  1590.                 
  1591.                 pddContext.addObject(org.openspcoop2.core.constants.Costanti.CORS_PREFLIGHT_REQUEST_TRASPARENTE, "true");
  1592.                 corsTrasparente = true;
  1593.                 
  1594.             }
  1595.             
  1596.         }
  1597.         
  1598.         
  1599.         
  1600.         
  1601.         

  1603.         
  1604.         
  1605.         Utilities.printFreeMemory("RicezioneContenutiApplicativi - Autorizzazione canale ...");
  1606.         ConfigurazioneCanaliNodo configurazioneCanaliNodo = null;
  1607.         try {   
  1608.             configurazioneCanaliNodo = configurazionePdDReader.getConfigurazioneCanaliNodo(); 
  1609.         } catch (Exception e) {
  1610.             msgDiag.logErroreGenerico(e, "configurazionePdDReader.getConfigurazioneCanaliNodo()");
  1611.             openspcoopstate.releaseResource();
  1612.             if (this.msgContext.isGestioneRisposta()) {
  1613.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_REQUEST_ERROR, 
  1614.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1615.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE), e,null)));
  1616.             }
  1617.             return;
  1618.         }
  1619.         boolean canaleNonAutorizzato = false;
  1620.         try {
  1621.             if(configurazioneCanaliNodo!=null && configurazioneCanaliNodo.isEnabled()) {
  1622.             
  1623.                 msgDiag.addKeyword(CostantiPdD.KEY_DETAILS, "");
  1624.                 msgDiag.logPersonalizzato("autorizzazioneCanale.inCorso");
  1625.                 
  1626.                 String canaleApiInvocata = null;
  1627.                 if(portaDelegata!=null) {
  1628.                     String canalePorta = portaDelegata.getCanale();
  1629.                     if(canalePorta!=null && !"".equals(canalePorta)) {
  1630.                         canaleApiInvocata = canalePorta;
  1631.                     }
  1632.                     else {
  1633.                         try {
  1634.                             AccordoServizioParteSpecifica asps = registroServiziReader.getAccordoServizioParteSpecifica(idServizio, null, false, requestInfo);
  1635.                             if(asps!=null) {
  1636.                                 AccordoServizioParteComune aspc = registroServiziReader.getAccordoServizioParteComune(IDAccordoFactory.getInstance().getIDAccordoFromUri(asps.getAccordoServizioParteComune()), null, false, false, requestInfo);
  1637.                                 if(aspc!=null) {
  1638.                                     String canaleApi = aspc.getCanale();
  1639.                                     if(canaleApi!=null && !"".equals(canaleApi)) {
  1640.                                         canaleApiInvocata = canaleApi;
  1641.                                     }
  1642.                                 }
  1643.                             }
  1644.                         }catch(DriverRegistroServiziNotFound notFound) {
  1645.                             // saranno segnalati altri errori dovuti al non riconoscimento del servizio
  1646.                         }
  1647.                     }
  1648.                     
  1649.                     if(canaleApiInvocata==null || "".equals(canaleApiInvocata)) {
  1650.                         canaleApiInvocata = configurazioneCanaliNodo.getCanaleDefault();
  1651.                     }
  1652.                     
  1653.                     if(!configurazioneCanaliNodo.getCanaliNodo().contains(canaleApiInvocata)) {
  1654.                         canaleNonAutorizzato = true;
  1655.                         String dettaglio=" (nodo '"+configurazioneCanaliNodo.getIdNodo()+"':"+configurazioneCanaliNodo.getCanaliNodo()+" api-invocata:"+canaleApiInvocata+")";
  1656.                         msgDiag.addKeyword(CostantiPdD.KEY_DETAILS, dettaglio);
  1657.                         pddContext.addObject(org.openspcoop2.core.constants.Costanti.ERRORE_AUTORIZZAZIONE, "true");
  1658.                         throw new Exception("L'API invocata richiede un canale differente da quelli associati al nodo; invocazione non autorizzata");
  1659.                     }
  1660.                     else {
  1661.                         msgDiag.logPersonalizzato("autorizzazioneCanale.effettuata");
  1662.                     }
  1663.                     
  1664.                 }
  1665. //              else {
  1666. //                  // saranno segnalati altri errori dovuti al non riconoscimento della porta
  1667. //              }
  1668.                 
  1669.             }
  1670.         } catch (Exception e) {
  1671.             
  1672.             String msgErrore = e.getMessage();
  1673.             
  1674.             msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, msgErrore);
  1675.             msgDiag.logPersonalizzato("autorizzazioneCanale.fallita");
  1676.             
  1677.             ErroreIntegrazione errore = canaleNonAutorizzato ? ErroriIntegrazione.ERRORE_404_AUTORIZZAZIONE_FALLITA_SA_ANONIMO.getErrore404_AutorizzazioneFallitaServizioApplicativoAnonimo(msgErrore) : 
  1678.                 ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE);
  1679.             IntegrationFunctionError integrationFunctionError = canaleNonAutorizzato ? IntegrationFunctionError.AUTHORIZATION_DENY : IntegrationFunctionError.INTERNAL_REQUEST_ERROR;

  1681.             openspcoopstate.releaseResource();
  1682.             if (this.msgContext.isGestioneRisposta()) {
  1683.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,integrationFunctionError, errore, e,null)));
  1684.             }
  1685.             return;
  1686.         }
  1687.         
  1688.         
  1689.         
  1690.         
  1691.         
  1692.         
  1693.         
  1694.         
  1695.         
  1696.         
  1697.         Utilities.printFreeMemory("RicezioneContenutiApplicativi - Identificazione PD specifica per azione del servizio ...");
  1698.         
  1699.         msgDiag.mediumDebug("Lettura azione associato alla PD invocata...");
  1700.         if(richiestaDelegata.getIdServizio().getAzione()!=null && portaDelegata!=null) {
  1701.             // verifico se esiste una porta delegata piu' specifica
  1702.             IdentificazionePortaDelegata identificazione = new IdentificazionePortaDelegata(logCore, protocolFactory, 
  1703.                     registroServiziReader, configurazionePdDReader, requestInfo,
  1704.                     portaDelegata);
  1705.             String action = richiestaDelegata.getIdServizio().getAzione();
  1706.             if(identificazione.find(action)) {
  1707.                 IDPortaDelegata idPD_action = identificazione.getIDPortaDelegata(action);
  1708.                 if(idPD_action!=null) {
  1709.                     
  1710.                     requestMessage.addContextProperty(CostantiPdD.NOME_PORTA_INVOCATA, portaDelegata.getNome()); // prima di aggiornare la porta delegata
  1711.                     
  1712.                     identificativoPortaDelegata = idPD_action;
  1713.                     portaDelegata = identificazione.getPortaDelegata(action);
  1714.                     nomeUtilizzatoPerErrore = "Configurazione specifica per l'azione '"+action+"', porta '"+ identificativoPortaDelegata.getNome()+"'";
  1715.                                         
  1716.                     // aggiornao dati che possiede la Porta Delegata ID Porta Delegata
  1717.                     this.msgContext.getIntegrazione().setIdPD(identificativoPortaDelegata);
  1718.                     msgDiag.addKeyword(CostantiPdD.KEY_PORTA_DELEGATA, identificativoPortaDelegata.getNome());
  1719.                     msgDiag.updatePorta(identificativoPortaDelegata.getNome(), requestInfo);
  1720.                     richiestaDelegata.setIdPortaDelegata(identificativoPortaDelegata);
  1721.                     if(requestMessage.getTransportRequestContext()!=null) {
  1722.                         requestMessage.getTransportRequestContext().setInterfaceName(identificativoPortaDelegata.getNome());
  1723.                     }
  1724.                     
  1725.                     pddContext.removeObject(org.openspcoop2.core.constants.Costanti.PROPRIETA_CONFIGURAZIONE);
  1726.                     try {
  1727.                         Map<String, String> configProperties = configurazionePdDReader.getProprietaConfigurazione(portaDelegata);
  1728.                         if (configProperties != null && !configProperties.isEmpty()) {
  1729.                            pddContext.addObject(org.openspcoop2.core.constants.Costanti.PROPRIETA_CONFIGURAZIONE, configProperties);
  1730.                         }
  1731.                     }catch(Exception e) {
  1732.                         logError(logCore, "Errore durante la lettura delle proprietร  di configurazione della porta delegata [" + portaDelegata.getNome() + "]: " + e.getMessage(), e);
  1733.                     }
  1734.                 }
  1735.             }else {
  1736.                 pddContext.addObject(org.openspcoop2.core.constants.Costanti.API_NON_INDIVIDUATA, "true");
  1737.                 msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, identificazione.getErroreIntegrazione().getDescrizione(protocolFactory));
  1738.                 msgDiag.logPersonalizzato("portaDelegataNonEsistente");
  1739.                 openspcoopstate.releaseResource();
  1740.                 if (this.msgContext.isGestioneRisposta()) {
  1741.                     IntegrationFunctionError integrationFunctionError = null;
  1742.                     if(CodiceErroreIntegrazione.CODICE_401_PORTA_INESISTENTE.equals(identificazione.getErroreIntegrazione().getCodiceErrore())){
  1743.                         integrationFunctionError = IntegrationFunctionError.API_OUT_UNKNOWN;
  1744.                     }else{
  1745.                         integrationFunctionError = IntegrationFunctionError.INTERNAL_REQUEST_ERROR;
  1746.                     }
  1747.                     this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,integrationFunctionError, identificazione.getErroreIntegrazione(),null,null)));
  1748.                 }
  1749.                 return;
  1750.             }
  1751.         }
  1752.         
  1753.         
  1754.         
  1755.         


  1758.         
  1759.         
  1760.         
  1761.         
  1762.         // ------------- Informazioni Integrazione -----------------------------
  1763.         
  1764.         msgDiag.mediumDebug("Aggiungo informazioni di integrazione dinamica nel contesto ...");
  1765.                 
  1766.         try {
  1767.             if(portaDelegata!=null) {
  1768.                 configurazionePdDReader.setInformazioniIntegrazioneDinamiche(logCore, urlProtocolContext, pddContext, portaDelegata);
  1769.             }
  1770.         } 
  1771.         catch (Exception e) {
  1772.             msgDiag.logErroreGenerico(e, "setInformazioniIntegrazioneDinamiche");
  1773.             openspcoopstate.releaseResource();
  1774.             if (this.msgContext.isGestioneRisposta()) {
  1775.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.BAD_REQUEST,
  1776.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1777.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE), e,null)));
  1778.             }
  1779.             return;
  1780.         }
  1781.         
  1782.         
  1783.         
  1784.         
  1785.         
  1786.         
  1787.         
  1788.         // ------------- Dump richiesta-----------------------------
  1789.         
  1790.         msgDiag.mediumDebug("Dump richiesta ...");
  1791.         
  1792.         DumpConfigurazione dumpConfig = null;
  1793.         try {
  1794.             dumpConfig = configurazionePdDReader.getDumpConfigurazione(portaDelegata);
  1795.             internalObjects.put(CostantiPdD.DUMP_CONFIG, dumpConfig);
  1796.         } 
  1797.         catch (Exception e) {
  1798.             msgDiag.logErroreGenerico(e, "readDumpConfigurazione");
  1799.             openspcoopstate.releaseResource();
  1800.             if (this.msgContext.isGestioneRisposta()) {
  1801.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_REQUEST_ERROR,
  1802.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1803.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE), e,null)));
  1804.             }
  1805.             return;
  1806.         }
  1807.         
  1808.         Dump dumpApplicativo = new Dump(identitaPdD,
  1809.                 this.msgContext.getIdModulo(), null,
  1810.                 soggettoFruitore, richiestaDelegata.getIdServizio(),
  1811.                 this.msgContext.getTipoPorta(), msgDiag.getPorta(), inRequestContext.getPddContext(),
  1812.                 openspcoopstate.getStatoRichiesta(),openspcoopstate.getStatoRisposta(),
  1813.                 dumpConfig);
  1814.         dumpApplicativo.dumpRichiestaIngresso(requestMessage,inRequestContext.getConnettore().getUrlProtocolContext());
  1815.         internalObjects.put(CostantiPdD.DUMP_RICHIESTA_EFFETTUATO, true);
  1816.         
  1817.         
  1818.         
  1819.         
  1820.         
  1821.         
  1822.         
  1823.         
  1824.         
  1825.         
  1826.         
  1827.         
  1828.         
  1829.         
  1830.         
  1831.         Utilities.printFreeMemory("RicezioneContenutiApplicativi - Autenticazione ...");
  1832.         
  1833.         

  1835.         /* --------------- Gestione credenziali --------------- */
  1836.         if(RicezioneContenutiApplicativi.tipiGestoriCredenziali!=null){
  1837.             msgDiag.mediumDebug("Gestione personalizzata delle credenziali...");
  1838.             
  1839.             for (int i = 0; i < RicezioneContenutiApplicativi.tipiGestoriCredenziali.length; i++) {
  1840.                 try {
  1841.                                 
  1842.                     IGestoreCredenziali gestore = null;
  1843.                     String classType = null;
  1844.                     try {
  1845.                         classType = className.getGestoreCredenziali(RicezioneContenutiApplicativi.tipiGestoriCredenziali[i]);
  1846.                         gestore = (IGestoreCredenziali)loader.newInstance(classType);
  1847.                         AbstractCore.init(gestore, pddContext, protocolFactory);
  1848.                     } catch (Exception e) {
  1849.                         throw new Exception(
  1850.                                 "Riscontrato errore durante il caricamento della classe ["+ classType
  1851.                                 + "] da utilizzare per la gestione delle credenziali di tipo ["
  1852.                                 + RicezioneContenutiApplicativi.tipiGestoriCredenziali[i]+ "]: " + e.getMessage());
  1853.                     }
  1854.                     
  1855.                     if (gestore != null) {
  1856.                         Credenziali credenzialiRitornate = gestore.elaborazioneCredenziali(identitaPdD, inRequestContext.getConnettore(), requestMessage);
  1857.                         if(credenzialiRitornate==null){
  1858.                             throw new Exception("Credenziali non ritornate");
  1859.                         }
  1860.                         if(inRequestContext.getConnettore().getCredenziali().equals(credenzialiRitornate) == false){
  1861.                             String nuoveCredenziali = credenzialiRitornate.toString();
  1862.                             if(nuoveCredenziali.length()>0) {
  1863.                                 nuoveCredenziali = nuoveCredenziali.substring(0,(nuoveCredenziali.length()-1));
  1864.                             }
  1865.                             msgDiag.addKeyword(CostantiPdD.KEY_NUOVE_CREDENZIALI,nuoveCredenziali);
  1866.                             String identita = gestore.getIdentitaGestoreCredenziali();
  1867.                             if(identita==null){
  1868.                                 identita = "Gestore delle credenziali di tipo "+RicezioneContenutiApplicativi.tipiGestoriCredenziali[i];
  1869.                             }
  1870.                             msgDiag.addKeyword(CostantiPdD.KEY_IDENTITA_GESTORE_CREDENZIALI, identita);
  1871.                             pddContext.addObject(org.openspcoop2.core.constants.Costanti.IDENTITA_GESTORE_CREDENZIALI, identita);
  1872.                             msgDiag.logPersonalizzato("gestoreCredenziali.nuoveCredenziali");
  1873.                             // update credenziali
  1874.                             inRequestContext.getConnettore().setCredenziali(credenzialiRitornate);
  1875.                             credenziali = credenzialiRitornate;
  1876.                             setCredenziali(credenziali, msgDiag);   
  1877.                         }
  1878.                     } else {
  1879.                         throw new Exception("non inizializzato");
  1880.                     }
  1881.                 } 
  1882.                 catch (Exception e) {
  1883.                     logError(logCore, "Errore durante l'identificazione delle credenziali ["+ RicezioneContenutiApplicativi.tipiGestoriCredenziali[i]
  1884.                              + "]: "+ e.getMessage(),e);
  1885.                     msgDiag.addKeyword(CostantiPdD.KEY_TIPO_GESTORE_CREDENZIALI,RicezioneContenutiApplicativi.tipiGestoriCredenziali[i]);
  1886.                     msgDiag.addKeywordErroreProcessamento(e);
  1887.                     msgDiag.logPersonalizzato("gestoreCredenziali.errore");
  1888.                     ErroreIntegrazione errore = null;
  1889.                     IntegrationFunctionError integrationFunctionError = null;
  1890.                     String wwwAuthenticateErrorHeader = null;
  1891.                     if(e instanceof GestoreCredenzialiConfigurationException){
  1892.                         errore = ErroriIntegrazione.ERRORE_431_GESTORE_CREDENZIALI_ERROR.
  1893.                                 getErrore431_ErroreGestoreCredenziali(RicezioneContenutiApplicativi.tipiGestoriCredenziali[i], e);
  1894.                         GestoreCredenzialiConfigurationException ge = (GestoreCredenzialiConfigurationException) e;
  1895.                         integrationFunctionError = ge.getIntegrationFunctionError();
  1896.                         pddContext.addObject(org.openspcoop2.core.constants.Costanti.ERRORE_AUTENTICAZIONE, "true");
  1897.                         wwwAuthenticateErrorHeader = ge.getWwwAuthenticateErrorHeader();
  1898.                     }else{
  1899.                         errore = ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  1900.                                 get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_548_GESTORE_CREDENZIALI_NON_FUNZIONANTE);
  1901.                         integrationFunctionError = IntegrationFunctionError.INTERNAL_REQUEST_ERROR;
  1902.                     }
  1903.                     openspcoopstate.releaseResource();
  1904.                     if (this.msgContext.isGestioneRisposta()) {
  1905.                         OpenSPCoop2Message errorMsg = this.generatoreErrore.build(pddContext,integrationFunctionError, errore,e,null);
  1906.                         if(wwwAuthenticateErrorHeader!=null) {
  1907.                             errorMsg.forceTransportHeader(HttpConstants.AUTHORIZATION_RESPONSE_WWW_AUTHENTICATE, wwwAuthenticateErrorHeader);
  1908.                         }
  1909.                         this.msgContext.setMessageResponse(errorMsg);
  1910.                     }
  1911.                     return;
  1912.                 }
  1913.             }
  1914.         }
  1915.         
  1916.         
  1917.         
  1918.         
  1919.         
  1920.         
  1921.         
  1922.         
  1923.         
  1924.         
  1925.         
  1926.         
  1927.         
  1928.         
  1929.         
  1930.         /* ------------ GestioneToken ------------- */
  1931.     
  1932.         RicezioneContenutiApplicativiGestioneToken gestioneToken = new RicezioneContenutiApplicativiGestioneToken(msgDiag, logCore,
  1933.                 portaDelegata, identificativoPortaDelegata,
  1934.                 requestMessage,
  1935.                 this.msgContext, this.generatoreErrore, inRequestContext,
  1936.                 configurazionePdDReader,
  1937.                 pddContext, idTransazione,
  1938.                 openspcoopstate, transaction, requestInfo,
  1939.                 protocolFactory,
  1940.                 identitaPdD);
  1941.     
  1942.         GestioneTokenAutenticazione gestioneTokenAutenticazione = null;
  1943.         String token = null;
  1944.         if(!gestioneToken.process()) {
  1945.             return;
  1946.         }
  1947.         gestioneTokenAutenticazione = gestioneToken.getGestioneTokenAutenticazione();
  1948.         token = gestioneToken.getToken();
  1949.         
  1950.         
  1951.         
  1952.         
  1953.         
  1954.         
  1955.         
  1956.         
  1957.         
  1958.         
  1959.         /* ------------ Autenticazione ------------- */
  1960.         
  1961.         RicezioneContenutiApplicativiGestioneAutenticazione gestioneAutenticazione = new RicezioneContenutiApplicativiGestioneAutenticazione(msgDiag, logCore,
  1962.                 portaDelegata, identificativoPortaDelegata,
  1963.                 soggettoFruitore, credenziali, gestioneTokenAutenticazione, richiestaDelegata, proprietaErroreAppl,
  1964.                 requestMessage,
  1965.                 this.msgContext, this.generatoreErrore, inRequestContext, headerIntegrazioneRichiesta,
  1966.                 configurazionePdDReader, registroServiziReader,
  1967.                 pddContext, idTransazione, identitaPdD,
  1968.                 openspcoopstate, transaction, requestInfo,
  1969.                 protocolFactory);
  1970.         
  1971.         IDServizioApplicativo idApplicativoToken = null;
  1972.         ServizioApplicativo sa = null;
  1973.         String servizioApplicativo = null;
  1974.         InformazioniToken informazioniTokenNormalizzate = null;
  1975.         
  1976.         if(!gestioneAutenticazione.process()) {
  1977.             return;
  1978.         }
  1979.         
  1980.         idApplicativoToken = gestioneAutenticazione.getIdApplicativoToken();
  1981.         sa = gestioneAutenticazione.getSa();
  1982.         servizioApplicativo = gestioneAutenticazione.getServizioApplicativo();
  1983.         informazioniTokenNormalizzate = gestioneAutenticazione.getInformazioniTokenNormalizzate();
  1984.         
  1985.         
  1986.         
  1987.         

  1989.         
  1990.         
  1991.         
  1992.         /* --------------- Verifica tipo soggetto fruitore e tipo servizio rispetto al canale utilizzato --------------- */
  1993.         msgDiag.mediumDebug("Verifica canale utilizzato...");
  1994.         List<String> tipiSoggettiSupportatiCanale = protocolFactory.createProtocolConfiguration().getTipiSoggetti();
  1995.         List<String> tipiServiziSupportatiCanale = protocolFactory.createProtocolConfiguration().getTipiServizi(requestMessage.getServiceBinding());
  1996.         // Nota: se qualche informazione e' null verranno segnalati altri errori
  1997.         if(soggettoFruitore!=null && soggettoFruitore.getTipo()!=null && 
  1998.                 tipiSoggettiSupportatiCanale.contains(soggettoFruitore.getTipo())==false){
  1999.             msgDiag.logPersonalizzato("protocolli.tipoSoggetto.fruitore.unsupported");
  2000.             openspcoopstate.releaseResource();
  2001.             if (this.msgContext.isGestioneRisposta()) {
  2002.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.NOT_SUPPORTED_BY_PROTOCOL,
  2003.                         ErroriIntegrazione.ERRORE_436_TIPO_SOGGETTO_FRUITORE_NOT_SUPPORTED_BY_PROTOCOL.
  2004.                         getErrore436_TipoSoggettoFruitoreNotSupportedByProtocol(soggettoFruitore,protocolFactory),null,null)));
  2005.             }
  2006.             return;
  2007.         }
  2008.         if(richiestaDelegata!=null && richiestaDelegata.getIdServizio()!=null &&
  2009.                 richiestaDelegata.getIdServizio().getSoggettoErogatore()!=null && 
  2010.                 richiestaDelegata.getIdServizio().getSoggettoErogatore().getTipo()!=null &&
  2011.                 tipiSoggettiSupportatiCanale.contains(richiestaDelegata.getIdServizio().getSoggettoErogatore().getTipo())==false){
  2012.             msgDiag.logPersonalizzato("protocolli.tipoSoggetto.erogatore.unsupported");
  2013.             openspcoopstate.releaseResource();
  2014.             if (this.msgContext.isGestioneRisposta()) {
  2015.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.NOT_SUPPORTED_BY_PROTOCOL,
  2016.                         ErroriIntegrazione.ERRORE_437_TIPO_SOGGETTO_EROGATORE_NOT_SUPPORTED_BY_PROTOCOL.
  2017.                         getErrore437_TipoSoggettoErogatoreNotSupportedByProtocol(richiestaDelegata.getIdServizio().getSoggettoErogatore(),protocolFactory),null,null)));
  2018.             }
  2019.             return;
  2020.         }
  2021.         if(richiestaDelegata!=null && richiestaDelegata.getIdServizio()!=null &&
  2022.                 richiestaDelegata.getIdServizio().getTipo()!=null && 
  2023.                 tipiServiziSupportatiCanale.contains(richiestaDelegata.getIdServizio().getTipo())==false){
  2024.             msgDiag.logPersonalizzato("protocolli.tipoServizio.unsupported");
  2025.             openspcoopstate.releaseResource();
  2026.             if (this.msgContext.isGestioneRisposta()) {
  2027.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.NOT_SUPPORTED_BY_PROTOCOL,
  2028.                         ErroriIntegrazione.ERRORE_438_TIPO_SERVIZIO_NOT_SUPPORTED_BY_PROTOCOL.
  2029.                         getErrore438_TipoServizioNotSupportedByProtocol(requestMessage.getServiceBinding(),
  2030.                                 richiestaDelegata.getIdServizio(),protocolFactory),null,null)));
  2031.             }
  2032.             return;
  2033.         }
  2034.         if(idApplicativoToken!=null && idApplicativoToken.getIdSoggettoProprietario()!=null &&
  2035.                 idApplicativoToken.getIdSoggettoProprietario().getTipo()!=null && 
  2036.                 tipiSoggettiSupportatiCanale.contains(idApplicativoToken.getIdSoggettoProprietario().getTipo())==false){
  2037.             msgDiag.logPersonalizzato("protocolli.tipoSoggetto.applicativoToken.unsupported");
  2038.             openspcoopstate.releaseResource();
  2039.             if (this.msgContext.isGestioneRisposta()) {
  2040.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.NOT_SUPPORTED_BY_PROTOCOL,
  2041.                         ErroriIntegrazione.ERRORE_449_TIPO_SOGGETTO_APPLICATIVO_TOKEN_NOT_SUPPORTED_BY_PROTOCOL.
  2042.                             getErrore449_TipoSoggettoApplicativoTokenNotSupportedByProtocol(idApplicativoToken,protocolFactory),null,null)));
  2043.             }
  2044.             return;
  2045.         }
  2046.         
  2047.         
  2048.         
  2049.         
  2050.         
  2051.         
  2052.         
  2053.         /*
  2054.          * ---------------- Verifico che il servizio di RicezioneContenutiApplicativi sia abilitato ---------------------
  2055.          */
  2056.         boolean serviceIsEnabled = false;
  2057.         boolean portaEnabled = false;
  2058.         Exception serviceIsEnabledExceptionProcessamento = null;
  2059.         try{
  2060.             serviceIsEnabled = StatoServiziPdD.isEnabledPortaDelegata(soggettoFruitore, richiestaDelegata.getIdServizio());
  2061.             if(serviceIsEnabled){
  2062.                 portaEnabled = configurazionePdDReader.isPortaAbilitata(portaDelegata);
  2063.             }
  2064.         }catch(Exception e){
  2065.             serviceIsEnabledExceptionProcessamento = e;
  2066.         }
  2067.         if (!serviceIsEnabled || !portaEnabled  || serviceIsEnabledExceptionProcessamento!=null) {
  2068.             ErroreIntegrazione errore = null;
  2069.             IntegrationFunctionError integrationFunctionError = IntegrationFunctionError.API_SUSPEND;
  2070.             if(serviceIsEnabledExceptionProcessamento!=null){
  2071.                 logError(logCore, "["+ RicezioneContenutiApplicativi.ID_MODULO+ "] Identificazione stato servizio di ricezione contenuti applicativi non riuscita: "+serviceIsEnabledExceptionProcessamento.getMessage(),serviceIsEnabledExceptionProcessamento);
  2072.                 msgDiag.logErroreGenerico("Identificazione stato servizio di ricezione contenuti applicativi non riuscita", "PD");
  2073.                 errore = ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreIntegrazione();
  2074.                 integrationFunctionError = IntegrationFunctionError.INTERNAL_REQUEST_ERROR;
  2075.             }else{
  2076.                 
  2077.                 pddContext.addObject(org.openspcoop2.core.constants.Costanti.ERRORE_SOSPENSIONE, "true");
  2078.                                 
  2079.                 String msg = "Servizio di ricezione contenuti applicativi disabilitato";
  2080.                 if(serviceIsEnabled){
  2081.                     msg = "Porta Delegata ["+nomeUtilizzatoPerErrore+"] disabilitata";
  2082.                     errore = ErroriIntegrazione.ERRORE_446_PORTA_SOSPESA.getErroreIntegrazione();
  2083.                 }
  2084.                 else {
  2085.                     errore = ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  2086.                             get5XX_ErroreProcessamento(msg,CodiceErroreIntegrazione.CODICE_550_PD_SERVICE_NOT_ACTIVE);
  2087.                 }
  2088.                 logError(logCore, "["+ RicezioneContenutiApplicativi.ID_MODULO+ "] "+msg);
  2089.                 msgDiag.logErroreGenerico(msg, "PD");
  2090.             }
  2091.             openspcoopstate.releaseResource();
  2092.             if (this.msgContext.isGestioneRisposta()) {
  2093.                 OpenSPCoop2Message errorOpenSPCoopMsg = this.generatoreErrore.build(pddContext,integrationFunctionError,
  2094.                         errore,serviceIsEnabledExceptionProcessamento,null);
  2095.                 if(IntegrationFunctionError.API_SUSPEND.equals(integrationFunctionError) &&
  2096.                         propertiesReader.isEnabledServiceUnavailableRetryAfterPDSuspend() && 
  2097.                         propertiesReader.getServiceUnavailableRetryAfterSecondsPDSuspend()!=null &&
  2098.                         propertiesReader.getServiceUnavailableRetryAfterSecondsPDSuspend()>0) {
  2099.                     int seconds = propertiesReader.getServiceUnavailableRetryAfterSecondsPDSuspend();
  2100.                     if(propertiesReader.getServiceUnavailableRetryAfterSecondsRandomBackoffPDSuspend()!=null &&
  2101.                             propertiesReader.getServiceUnavailableRetryAfterSecondsRandomBackoffPDSuspend()>0) {
  2102.                         seconds = seconds + ServicesUtils.getRandom().nextInt(propertiesReader.getServiceUnavailableRetryAfterSecondsRandomBackoffPDSuspend());
  2103.                     }
  2104.                     errorOpenSPCoopMsg.forceTransportHeader(HttpConstants.RETRY_AFTER, seconds+"");
  2105.                 }
  2106.                 this.msgContext.setMessageResponse(errorOpenSPCoopMsg);
  2107.             }
  2108.             return;
  2109.         }
  2110.         
  2111.         
  2112.         
  2113.         
  2114.         
  2115.         
  2116.         
  2117.         
  2118.         
  2119.         
  2120.         /* ------------ Gestione Attribute Authority ------------- */
  2121.         
  2122.         msgDiag.mediumDebug("Gestione Attribute Authority...");
  2123.         List<AttributeAuthority> attributeAuthorities = null;
  2124.         if(portaDelegata!=null) {
  2125.             attributeAuthorities = portaDelegata.getAttributeAuthorityList();
  2126.         }
  2127.         this.msgContext.getIntegrazione().setAttributeAuthoritiesFromObjectList(attributeAuthorities);
  2128.         
  2129.         if (attributeAuthorities == null || attributeAuthorities.isEmpty()) {

  2131.             msgDiag.logPersonalizzato("gestioneAADisabilitata");
  2132.             
  2133.         } else {

  2135.             transaction.getTempiElaborazione().startAttributeAuthority();
  2136.             
  2137.             try {
  2138.                 msgDiag.logPersonalizzato("gestioneAAInCorso");
  2139.                 
  2140.                 org.openspcoop2.pdd.core.token.attribute_authority.pd.DatiInvocazionePortaDelegata datiInvocazione = new org.openspcoop2.pdd.core.token.attribute_authority.pd.DatiInvocazionePortaDelegata();
  2141.                 datiInvocazione.setInfoConnettoreIngresso(inRequestContext.getConnettore());
  2142.                 datiInvocazione.setState(openspcoopstate.getStatoRichiesta());
  2143.                 datiInvocazione.setIdModulo(inRequestContext.getIdModulo());
  2144.                 datiInvocazione.setMessage(requestMessage);
  2145.                 Busta busta = new Busta(protocolFactory.getProtocol());
  2146.                 if(soggettoFruitore!=null) {
  2147.                     busta.setTipoMittente(soggettoFruitore.getTipo());
  2148.                     busta.setMittente(soggettoFruitore.getNome());
  2149.                 }
  2150.                 if(richiestaDelegata!=null && richiestaDelegata.getIdServizio()!=null) {
  2151.                     if(richiestaDelegata.getIdServizio().getSoggettoErogatore()!=null) {
  2152.                         busta.setTipoDestinatario(richiestaDelegata.getIdServizio().getSoggettoErogatore().getTipo());
  2153.                         busta.setDestinatario(richiestaDelegata.getIdServizio().getSoggettoErogatore().getNome());
  2154.                     }
  2155.                     busta.setTipoServizio(richiestaDelegata.getIdServizio().getTipo());
  2156.                     busta.setServizio(richiestaDelegata.getIdServizio().getNome());
  2157.                     busta.setVersioneServizio(richiestaDelegata.getIdServizio().getVersione());
  2158.                     busta.setAzione(richiestaDelegata.getIdServizio().getAzione());
  2159.                     if(sa!=null) {
  2160.                         busta.setServizioApplicativoFruitore(sa.getNome());
  2161.                     }
  2162.                 }
  2163.                 datiInvocazione.setBusta(busta);
  2164.                 datiInvocazione.setRequestInfo(requestInfo);
  2165.                 datiInvocazione.setIdPD(identificativoPortaDelegata);
  2166.                 datiInvocazione.setPd(portaDelegata);       
  2167.                 
  2168.                 GestioneAttributeAuthority gestioneAAEngine = new GestioneAttributeAuthority(logCore, idTransazione, pddContext, protocolFactory);
  2169.                 List<InformazioniAttributi> esitiValidiRecuperoAttributi = new ArrayList<InformazioniAttributi>();
  2170.                 
  2171.                 for (AttributeAuthority aa : attributeAuthorities) {
  2172.                     
  2173.                     try {
  2174.                         msgDiag.addKeyword(CostantiPdD.KEY_ATTRIBUTE_AUTHORITY_NAME, aa.getNome());
  2175.                         msgDiag.addKeyword(CostantiPdD.KEY_ATTRIBUTE_AUTHORITY_ENDPOINT, "-");
  2176.                         
  2177.                         PolicyAttributeAuthority policyAttributeAuthority = configurazionePdDReader.getPolicyAttributeAuthority(false, aa.getNome(), requestInfo);
  2178.                         datiInvocazione.setPolicyAttributeAuthority(policyAttributeAuthority);
  2179.                 
  2180.                         GestoreToken.validazioneConfigurazione(policyAttributeAuthority); // assicura che la configurazione sia corretta
  2181.                         
  2182.                         msgDiag.addKeyword(CostantiPdD.KEY_ATTRIBUTE_AUTHORITY_ENDPOINT, policyAttributeAuthority.getEndpoint());
  2183.                         
  2184.                         msgDiag.logPersonalizzato("gestioneAAInCorso.retrieve");
  2185.                         
  2186.                         EsitoRecuperoAttributi esitoRecuperoAttributi = gestioneAAEngine.readAttributes(datiInvocazione);
  2187.                         if(esitoRecuperoAttributi.isValido()) {
  2188.                             
  2189.                             StringBuilder attributiRecuperati = new StringBuilder();
  2190.                             if(esitoRecuperoAttributi.getInformazioniAttributi()!=null && 
  2191.                                     esitoRecuperoAttributi.getInformazioniAttributi().getAttributes()!=null &&
  2192.                                     !esitoRecuperoAttributi.getInformazioniAttributi().getAttributes().isEmpty()) {
  2193.                                 for (String attrName : esitoRecuperoAttributi.getInformazioniAttributi().getAttributesNames()) {
  2194.                                     if(attributiRecuperati.length()>0) {
  2195.                                         attributiRecuperati.append(",");
  2196.                                     }
  2197.                                     attributiRecuperati.append(attrName);
  2198.                                 }
  2199.                             }
  2200.                             msgDiag.addKeyword(CostantiPdD.KEY_ATTRIBUTES, attributiRecuperati.toString());
  2201.                             
  2202.                             if(esitoRecuperoAttributi.isInCache()) {
  2203.                                 msgDiag.logPersonalizzato("gestioneAAInCorso.retrieve.completataSuccesso.inCache");
  2204.                             }
  2205.                             else {
  2206.                                 msgDiag.logPersonalizzato("gestioneAAInCorso.retrieve.completataSuccesso");
  2207.                             }
  2208.                             
  2209.                             esitiValidiRecuperoAttributi.add(esitoRecuperoAttributi.getInformazioniAttributi());
  2210.                         }
  2211.                         else {
  2212.                             
  2213.                             msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, esitoRecuperoAttributi.getDetails());
  2214.                             msgDiag.logPersonalizzato("gestioneAAInCorso.retrieve.fallita");
  2215.         
  2216.                             String msgErrore = "processo di gestione dell'attribute authority ["+ aa.getNome() + "] fallito: " + esitoRecuperoAttributi.getDetails();
  2217.                             if(esitoRecuperoAttributi.getEccezioneProcessamento()!=null) {
  2218.                                 logError(logCore, msgErrore,esitoRecuperoAttributi.getEccezioneProcessamento());
  2219.                             }
  2220.                             else {
  2221.                                 logError(logCore, msgErrore);
  2222.                             }                           
  2223.                         }
  2224.                         
  2225.                     } catch (Throwable e) {
  2226.                         
  2227.                         msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, e.getMessage());
  2228.                         msgDiag.logPersonalizzato("gestioneAAInCorso.retrieve.fallita");
  2229.                         String msgErrore = "processo di gestione dell'attribute authority ["+ aa.getNome() + "] fallito: " + e.getMessage();
  2230.                         logError(logCore, msgErrore,e);
  2231.                         
  2232.                     }
  2233.                 }
  2234.                 
  2235.                 InformazioniAttributi informazioniAttributiNormalizzati = null;
  2236.                 if(esitiValidiRecuperoAttributi!=null && esitiValidiRecuperoAttributi.size()>0) {
  2237.                     informazioniAttributiNormalizzati = GestoreToken.normalizeInformazioniAttributi(esitiValidiRecuperoAttributi, attributeAuthorities);
  2238.                     informazioniAttributiNormalizzati.setValid(true);
  2239.                 }
  2240.                 if(informazioniAttributiNormalizzati!=null) {
  2241.                     pddContext.addObject(org.openspcoop2.pdd.core.token.Costanti.PDD_CONTEXT_ATTRIBUTI_INFORMAZIONI_NORMALIZZATE, informazioniAttributiNormalizzati);
  2242.                     
  2243.                     if(informazioniTokenNormalizzate!=null) {
  2244.                         informazioniTokenNormalizzate.setAa(informazioniAttributiNormalizzati);
  2245.                     }
  2246.                     else {
  2247.                         transaction.setInformazioniAttributi(informazioniAttributiNormalizzati);
  2248.                     }
  2249.                 }
  2250.                 
  2251.                 msgDiag.logPersonalizzato("gestioneAACompletata");
  2252.                 
  2253.             } catch (Throwable e) {
  2254.                 
  2255.                 msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, e.getMessage());
  2256.                 msgDiag.logPersonalizzato("gestioneAAFallita");
  2257.                 logError(logCore, "processo di gestione delle attribute authorities fallito: " + e.getMessage(),e);
  2258.                 
  2259.             }
  2260.             finally {
  2261.                 transaction.getTempiElaborazione().endAttributeAuthority();
  2262.             }
  2263.             
  2264.         }
  2265.         
  2266.         
  2267.         
  2268.         
  2269.         
  2270.         
  2271.         
  2272.         
  2273.         
  2274.         
  2275.         
  2276.         
  2277.         
  2278.         
  2279.         
  2280.         Utilities.printFreeMemory("RicezioneContenutiApplicativi - Inizializzazione connessione al database...");
  2281.         
  2282.         
  2283.         
  2284.         /*
  2285.          * ---------------- Inizializzazione Contesto di gestione della Richiesta ---------------------
  2286.          */
  2287.         String idMessageRequest = null;
  2288.         
  2289.         // Correlazione Applicativa
  2290.         msgDiag.mediumDebug("Gestione correlazione applicativa...");
  2291.         CorrelazioneApplicativa correlazionePD = null;
  2292.         try {
  2293.             correlazionePD = configurazionePdDReader.getCorrelazioneApplicativa(portaDelegata);
  2294.         } catch (Exception e) {
  2295.             msgDiag.logErroreGenerico(e,"getCorrelazioneApplicativa(pd)");
  2296.             openspcoopstate.releaseResource();
  2297.             if (this.msgContext.isGestioneRisposta()) {
  2298.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_REQUEST_ERROR,
  2299.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  2300.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE),e,null)));
  2301.             }
  2302.             return;
  2303.         }
  2304.         
  2305.         Busta busta = null;
  2306.         try {
  2307.             busta = new Busta(protocolFactory.getProtocol());
  2308.             if(soggettoFruitore!=null) {
  2309.                 busta.setTipoMittente(soggettoFruitore.getTipo());
  2310.                 busta.setMittente(soggettoFruitore.getNome());
  2311.             }
  2312.             if(richiestaDelegata!=null && richiestaDelegata.getIdServizio()!=null) {
  2313.                 if(richiestaDelegata.getIdServizio().getSoggettoErogatore()!=null) {
  2314.                     busta.setTipoDestinatario(richiestaDelegata.getIdServizio().getSoggettoErogatore().getTipo());
  2315.                     busta.setDestinatario(richiestaDelegata.getIdServizio().getSoggettoErogatore().getNome());
  2316.                 }
  2317.                 busta.setTipoServizio(richiestaDelegata.getIdServizio().getTipo());
  2318.                 busta.setServizio(richiestaDelegata.getIdServizio().getNome());
  2319.                 busta.setVersioneServizio(richiestaDelegata.getIdServizio().getVersione());
  2320.                 busta.setAzione(richiestaDelegata.getIdServizio().getAzione());
  2321.                 if(sa!=null) {
  2322.                     busta.setServizioApplicativoFruitore(sa.getNome());
  2323.                 }
  2324.             }
  2325.         }catch(Throwable t) {
  2326.             // ignore
  2327.         }
  2328.         
  2329.         GestoreCorrelazioneApplicativaConfig caConfig = new GestoreCorrelazioneApplicativaConfig();
  2330.         caConfig.setState(openspcoopstate.getStatoRichiesta());
  2331.         caConfig.setAlog(logCore);
  2332.         caConfig.setSoggettoFruitore(richiestaDelegata.getIdSoggettoFruitore());
  2333.         caConfig.setIdServizio(richiestaDelegata.getIdServizio());
  2334.         caConfig.setBusta(busta);
  2335.         caConfig.setServizioApplicativo(servizioApplicativo);
  2336.         caConfig.setProtocolFactory(protocolFactory);
  2337.         caConfig.setTransaction(transaction);
  2338.         caConfig.setPddContext(pddContext);
  2339.         caConfig.setPd(portaDelegata);
  2340.         GestoreCorrelazioneApplicativa correlazioneApplicativa = new GestoreCorrelazioneApplicativa(caConfig);
  2341.         
  2342.         boolean correlazioneEsistente = false;
  2343.         String idCorrelazioneApplicativa = null;
  2344.         if (correlazionePD != null) {
  2345.             try {
  2346.                 correlazioneApplicativa
  2347.                         .verificaCorrelazione(correlazionePD, urlProtocolContext,requestMessage,headerIntegrazioneRichiesta, 
  2348.                                 this.msgContext.getIdModulo().endsWith(IntegrationManager.ID_MODULO));
  2349.                 idCorrelazioneApplicativa = correlazioneApplicativa.getIdCorrelazione();
  2350.                 
  2351.                 if(correlazioneApplicativa.isRiusoIdentificativo()) {
  2352.                     
  2353.                     if(openspcoopstate.resourceReleased()) {
  2354.                         // inizializzo
  2355.                         openspcoopstate.setUseConnection(true);
  2356.                         openspcoopstate.initResource(identitaPdD, this.msgContext.getIdModulo(), idTransazione);
  2357.                         correlazioneApplicativa.updateState(openspcoopstate.getStatoRichiesta());
  2358.                     }
  2359.                     
  2360.                     correlazioneEsistente = correlazioneApplicativa.verificaCorrelazioneIdentificativoRichiesta();
  2361.                 }
  2362.                 
  2363.                 if (correlazioneEsistente) {
  2364.                     // Aggiornamento id richiesta
  2365.                     idMessageRequest = correlazioneApplicativa.getIdBustaCorrelato();

  2367.                     // Aggiornamento Informazioni Protocollo
  2368.                     msgDiag.setIdMessaggioRichiesta(idMessageRequest);
  2369.                     
  2370.                     // MsgDiagnostico
  2371.                     msgDiag.addKeyword(CostantiPdD.KEY_ID_CORRELAZIONE_APPLICATIVA, idCorrelazioneApplicativa);
  2372.                     msgDiag.addKeyword(CostantiPdD.KEY_ID_MESSAGGIO_RICHIESTA, idMessageRequest);
  2373.                     msgDiag.logPersonalizzato("correlazioneApplicativaEsistente");
  2374.                 }
  2375.             } catch (Exception e) {
  2376.                 
  2377.                 pddContext.addObject(org.openspcoop2.core.constants.Costanti.ERRORE_CORRELAZIONE_APPLICATIVA_RICHIESTA, "true");
  2378.                 
  2379.                 msgDiag.logErroreGenerico(e,"CorrelazioneApplicativa");
  2380.                 logError(logCore, "Riscontrato errore durante il controllo di correlazione applicativa: "+ e.getMessage(),e);
  2381.                 
  2382.                 ErroreIntegrazione errore = null;
  2383.                 if(correlazioneApplicativa!=null){
  2384.                     errore = correlazioneApplicativa.getErrore();
  2385.                 }
  2386.                 if(errore==null){
  2387.                     errore = ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  2388.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_529_CORRELAZIONE_APPLICATIVA_RICHIESTA_NON_RIUSCITA);
  2389.                 }

  2391.                 openspcoopstate.releaseResource();
  2392.                 if (this.msgContext.isGestioneRisposta()) {
  2393.                     IntegrationFunctionError integrationFunctionError = null;
  2394.                     if(CodiceErroreIntegrazione.CODICE_416_CORRELAZIONE_APPLICATIVA_RICHIESTA_ERRORE.equals(errore.getCodiceErrore())){
  2395.                         integrationFunctionError = IntegrationFunctionError.APPLICATION_CORRELATION_IDENTIFICATION_REQUEST_FAILED;
  2396.                     }
  2397.                     else{
  2398.                         integrationFunctionError = IntegrationFunctionError.INTERNAL_REQUEST_ERROR;
  2399.                     }
  2400.                     this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,integrationFunctionError,errore,e,null)));
  2401.                 }
  2402.                 return;
  2403.             }
  2404.         }

  2406.         if (correlazioneEsistente == false) {

  2408.             // Costruzione ID.
  2409.             msgDiag.mediumDebug("Costruzione identificativo...");
  2410.             try {
  2411.                 
  2412.                 Imbustamento imbustatore = new Imbustamento(logCore, protocolFactory,openspcoopstate.getStatoRichiesta());
  2413.                 idMessageRequest = 
  2414.                     imbustatore.buildID(identitaPdD, 
  2415.                             (String) this.msgContext.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE), 
  2416.                             propertiesReader.getGestioneSerializableDBAttesaAttiva(),
  2417.                             propertiesReader.getGestioneSerializableDBCheckInterval(),
  2418.                             RuoloMessaggio.RICHIESTA);
  2419.                 if (idMessageRequest == null) {
  2420.                     throw new Exception("Identificativo non costruito.");
  2421.                 }
  2422.                 // Aggiornamento Informazioni Protocollo
  2423.                 msgDiag.setIdMessaggioRichiesta(idMessageRequest);
  2424.                 
  2425.             } catch (Exception e) {
  2426.                 msgDiag.logErroreGenerico(e,"imbustatore.buildID(idMessageRequest)");
  2427.                 openspcoopstate.releaseResource();
  2428.                 if (this.msgContext.isGestioneRisposta()) {
  2429.                     this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_REQUEST_ERROR,
  2430.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  2431.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_507_COSTRUZIONE_IDENTIFICATIVO), e,null)));
  2432.                 }
  2433.                 return;
  2434.             }
  2435.             msgDiag.addKeyword(CostantiPdD.KEY_ID_MESSAGGIO_RICHIESTA, idMessageRequest);
  2436.             
  2437.             // Creazione Correlazione Applicativa
  2438.             if (correlazionePD!=null && idCorrelazioneApplicativa!=null && correlazioneApplicativa.isRiusoIdentificativo()) {
  2439.                 msgDiag.mediumDebug("Applicazione correlazione applicativa...");
  2440.                 try {
  2441.                     // Applica correlazione
  2442.                     correlazioneApplicativa.applicaCorrelazione(correlazionePD,idCorrelazioneApplicativa, idMessageRequest);
  2443.                                                 
  2444.                     // MsgDiagnostico
  2445.                     msgDiag.addKeyword(CostantiPdD.KEY_ID_CORRELAZIONE_APPLICATIVA, idCorrelazioneApplicativa);
  2446.                     msgDiag.logPersonalizzato("correlazioneApplicativaInstaurata");
  2447.                 } catch (Exception e) {
  2448.                     msgDiag.logErroreGenerico(e,"CreazioneCorrelazioneApplicativa");
  2449.                     
  2450.                     ErroreIntegrazione errore = null;
  2451.                     if(correlazioneApplicativa!=null){
  2452.                         errore = correlazioneApplicativa.getErrore();
  2453.                     }
  2454.                     if(errore==null){
  2455.                         errore = ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  2456.                                 get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_529_CORRELAZIONE_APPLICATIVA_RICHIESTA_NON_RIUSCITA);
  2457.                     }
  2458.                     
  2459.                     openspcoopstate.releaseResource();
  2460.                     if (this.msgContext.isGestioneRisposta()) {
  2461.                         IntegrationFunctionError integrationFunctionError = null;
  2462.                         if(CodiceErroreIntegrazione.CODICE_416_CORRELAZIONE_APPLICATIVA_RICHIESTA_ERRORE.equals(errore.getCodiceErrore())){
  2463.                             integrationFunctionError = IntegrationFunctionError.APPLICATION_CORRELATION_IDENTIFICATION_REQUEST_FAILED;
  2464.                         }
  2465.                         else{
  2466.                             integrationFunctionError = IntegrationFunctionError.INTERNAL_REQUEST_ERROR;
  2467.                         }
  2468.                         this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,integrationFunctionError,errore,null,null)));
  2469.                     }
  2470.                     return;
  2471.                 }
  2472.             }
  2473.         }
  2474.         richiestaDelegata.setIdCorrelazioneApplicativa(idCorrelazioneApplicativa);
  2475.         msgDiag.setIdCorrelazioneApplicativa(idCorrelazioneApplicativa);
  2476.         this.msgContext.getIntegrazione().setIdCorrelazioneApplicativa(idCorrelazioneApplicativa);
  2477.         this.msgContext.setIdMessage(idMessageRequest);
  2478.         this.msgContext.getProtocol().setIdRichiesta(idMessageRequest);
  2479.         
  2480.         
  2481.         
  2482.         Utilities.printFreeMemory("RicezioneContenutiApplicativi - Gestione header integrazione della risposta...");
  2483.         
  2484.         
  2485.         /*
  2486.          * ------- Imposta Risposta dell'Header Trasporto o se l'invocazione e' stata attiva dall'IntegrationManager -------
  2487.          */
  2488.         msgDiag.mediumDebug("Gestione header integrazione della risposta...");
  2489.         headerIntegrazioneRisposta.getBusta().setID(idMessageRequest);
  2490.         boolean containsHeaderIntegrazioneTrasporto = false;
  2491.         for (String gestore : defaultGestoriIntegrazionePD) {
  2492.             if(CostantiConfigurazione.HEADER_INTEGRAZIONE_TRASPORTO.equals(gestore)){
  2493.                 containsHeaderIntegrazioneTrasporto = true;
  2494.             }
  2495.         }
  2496.         if (containsHeaderIntegrazioneTrasporto
  2497.                 || this.msgContext.getIdModulo().startsWith(RicezioneContenutiApplicativi.ID_MODULO+ IntegrationManager.ID_MODULO)) {
  2498.             try {
  2499.                 Map<String, List<String>> propertiesIntegrazioneRisposta = new HashMap<>();

  2501.                 IGestoreIntegrazionePD gestore = null;
  2502.                 try {
  2503.                     gestore = (IGestoreIntegrazionePD) pluginLoader.newIntegrazionePortaDelegata(CostantiConfigurazione.HEADER_INTEGRAZIONE_TRASPORTO);
  2504.                 }catch(Exception e){
  2505.                     throw e;
  2506.                 }
  2507.                 if(gestore!=null){
  2508.                     String classType = null;
  2509.                     try {
  2510.                         classType = gestore.getClass().getName();
  2511.                         AbstractCore.init(gestore, pddContext, protocolFactory);
  2512.                     } catch (Exception e) {
  2513.                         throw new Exception(
  2514.                                 "Riscontrato errore durante l'inizializzazione della classe ["+ classType
  2515.                                         + "] da utilizzare per la gestione dell'integrazione delle fruizioni di tipo ["+ CostantiConfigurazione.HEADER_INTEGRAZIONE_TRASPORTO + "]: " + e.getMessage());
  2516.                     }

  2518.                     OutResponsePDMessage outResponsePDMessage = new OutResponsePDMessage();
  2519.                     outResponsePDMessage.setPortaDelegata(portaDelegata);
  2520.                     outResponsePDMessage.setHeaders(propertiesIntegrazioneRisposta);
  2521.                     outResponsePDMessage.setServizio(richiestaDelegata.getIdServizio());
  2522.                     outResponsePDMessage.setSoggettoMittente(soggettoFruitore);
  2523.                     gestore.setOutResponseHeader(headerIntegrazioneRisposta, outResponsePDMessage);
  2524.                     this.msgContext.setResponseHeaders(propertiesIntegrazioneRisposta);
  2525.                 }
  2526.             } catch (Exception e) {
  2527.                 msgDiag.logErroreGenerico(e,"setHeaderIntegrazioneRisposta");
  2528.             }
  2529.         }

  2531.         
  2532.         
  2533.         
  2534.         
  2535.         

  2537.         /*
  2538.           * --------- Informazioni protocollo ----------
  2539.          */
  2540.         IBustaBuilder<?> bustaBuilder = protocolFactory.createBustaBuilder(openspcoopstate.getStatoRichiesta());
  2541.         idServizio = richiestaDelegata.getIdServizio(); 
  2542.         this.msgContext.getProtocol().setFruitore(soggettoFruitore);    
  2543.         this.msgContext.getProtocol().setErogatore(idServizio.getSoggettoErogatore());      
  2544.         this.msgContext.getProtocol().setTipoServizio(idServizio.getTipo());
  2545.         this.msgContext.getProtocol().setServizio(idServizio.getNome());
  2546.         this.msgContext.getProtocol().setVersioneServizio(idServizio.getVersione());
  2547.         this.msgContext.getProtocol().setAzione(idServizio.getAzione());
  2548.         this.msgContext.getProtocol().setIdRichiesta(idMessageRequest);
  2549.         
  2550.         
  2551.         
  2552.         
  2553.         /*
  2554.           * --------- Dati di identificazione ----------
  2555.          */
  2556.         
  2557.         IDServizioApplicativo idServizioApplicativo = new IDServizioApplicativo();
  2558.         idServizioApplicativo.setNome(servizioApplicativo);
  2559.         idServizioApplicativo.setIdSoggettoProprietario(soggettoFruitore);
  2560.         
  2561.         
  2562.         
  2563.         

  2565.         
  2566.     
  2567.         
  2568.         
  2569.         
  2570.         /* -------------- Identificazione servizio ------------------ */
  2571.         String infoSearch = null;
  2572.         try{
  2573.             infoSearch = IDServizioFactory.getInstance().getUriFromIDServizio(idServizio);
  2574.         }catch(Exception e){
  2575.             infoSearch = idServizio.toString(false);
  2576.         }
  2577.         if (idServizio.getAzione() != null)
  2578.             infoSearch = infoSearch + " azione " + idServizio.getAzione();
  2579.         
  2580.         // Cerco nome del registro su cui cercare
  2581.         msgDiag.addKeyword(CostantiPdD.KEY_INFO_SERVIZIO_BUSTA,infoSearch );
  2582.         msgDiag.mediumDebug("Ricerca nome registro ["+infoSearch+"]...");
  2583.         String nomeRegistroForSearch = null;
  2584.         try {
  2585.             nomeRegistroForSearch = configurazionePdDReader.getRegistroForImbustamento(soggettoFruitore, idServizio, false, requestInfo);
  2586.         } catch (Exception e) {
  2587.             logError(logCore, "Connettore associato al servizio non trovato: "+e.getMessage(),e);
  2588.             msgDiag.addKeywordErroreProcessamento(e,"connettore associato al servizio non trovato");
  2589.             msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_IMBUSTAMENTO,"registroServizi.ricercaServizioFallita");
  2590.             openspcoopstate.releaseResource();
  2591.             if (this.msgContext.isGestioneRisposta()) {
  2592.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_REQUEST_ERROR,
  2593.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  2594.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_514_ROUTING_CONFIGURATION_ERROR), e,null)));
  2595.             }
  2596.             return;
  2597.         }

  2599.         
  2600.         // Gestisco riferimento asincrono
  2601.         String riferimentoServizioCorrelato_ricercaSolamenteServizioCorrelato = null;
  2602.         boolean supportoProfiliAsincroni = protocolConfig.isSupportato(requestInfo.getProtocolServiceBinding(),ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO)
  2603.                 || protocolConfig.isSupportato(requestInfo.getProtocolServiceBinding(),ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO);
  2604.         if(supportoProfiliAsincroni) {
  2605.             if (headerIntegrazioneRichiesta.getBusta() != null && headerIntegrazioneRichiesta.getBusta().getRiferimentoMessaggio() != null)
  2606.                 riferimentoServizioCorrelato_ricercaSolamenteServizioCorrelato = headerIntegrazioneRichiesta.getBusta().getRiferimentoMessaggio();      
  2607.             if(riferimentoServizioCorrelato_ricercaSolamenteServizioCorrelato==null){
  2608.                 // FIX compatibilita integrazione asincroni con versioni precedente a 1.4
  2609.                 // L'integrazione era possibile anche tramite info integrazione 'Collaborazione'
  2610.                 if(propertiesReader.isIntegrazioneAsincroniConIdCollaborazioneEnabled()){
  2611.                     if (headerIntegrazioneRichiesta.getBusta() != null && headerIntegrazioneRichiesta.getBusta().getIdCollaborazione() != null){
  2612.                         // utilizzo l'informazione come integrazione asincrona SOLO se il servizio e' correlato.
  2613.                         Servizio infoServizioTmpVerificaCorrelato = null;
  2614.                         try{
  2615.                             infoServizioTmpVerificaCorrelato = registroServiziReader.getInfoServizioCorrelato(soggettoFruitore,idServizio, nomeRegistroForSearch, true, requestInfo);
  2616.                         }catch(Exception e){
  2617.                             logDebug(logCore, "Verifica servizio ["+infoSearch+"] se e' correlato, fallita: "+e.getMessage());
  2618.                             try{
  2619.                                 infoServizioTmpVerificaCorrelato = registroServiziReader.getInfoServizioAzioneCorrelata(soggettoFruitore, idServizio,nomeRegistroForSearch, true, requestInfo);
  2620.                             }catch(Exception eCorrelato){
  2621.                                 logDebug(logCore, "Verifica servizio ["+infoSearch+"] se e' correlato rispetto all'azione, fallita: "+e.getMessage());
  2622.                             }
  2623.                         }
  2624.                         if(infoServizioTmpVerificaCorrelato!=null){
  2625.                             // Il servizio e' correlato!
  2626.                             riferimentoServizioCorrelato_ricercaSolamenteServizioCorrelato = headerIntegrazioneRichiesta.getBusta().getIdCollaborazione();
  2627.                         }
  2628.                     }   
  2629.                 }
  2630.             }
  2631.         }
  2632.         if (riferimentoServizioCorrelato_ricercaSolamenteServizioCorrelato != null) {
  2633.             infoSearch = "Servizio correlato " + infoSearch;
  2634.         } else {
  2635.             infoSearch = "Servizio " + infoSearch;
  2636.         }
  2637.         infoSearch = "Ricerca nel registro dei servizi di: " + infoSearch;
  2638.         if (riferimentoServizioCorrelato_ricercaSolamenteServizioCorrelato != null)
  2639.             infoSearch = infoSearch + " (idServizioCorrelato: "+ riferimentoServizioCorrelato_ricercaSolamenteServizioCorrelato + ")";
  2640.         msgDiag.addKeyword(CostantiPdD.KEY_INFO_SERVIZIO_BUSTA,infoSearch );
  2641.         msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_IMBUSTAMENTO,"registroServizi.ricercaServizioInCorso");
  2642.         
  2643.         // Effettuo ricerca
  2644.         boolean isServizioCorrelato = false;
  2645.         String invocazioneAzioneErrata = null;
  2646.         String portTypeErrato = null;
  2647.         boolean ricercaConErrore = false;
  2648.         boolean servizioCorrelatoNonTrovato = false;
  2649.         boolean servizioNonTrovato = false;
  2650.         Servizio infoServizio = null;
  2651.         Exception eServiceNotFound = null;
  2652.         try {
  2653.             // RiferimentoServizioCorrelato presente: cerco solo come servizio
  2654.             // correlato.
  2655.             if (riferimentoServizioCorrelato_ricercaSolamenteServizioCorrelato != null) {

  2657.                 String erroreRicerca = null;

  2659.                 // Ricerca come servizio correlato
  2660.                 msgDiag.mediumDebug("Ricerca servizio correlato ...");
  2661.                 try {
  2662.                     infoServizio = registroServiziReader.getInfoServizioCorrelato(soggettoFruitore,idServizio, nomeRegistroForSearch, true, requestInfo);
  2663.                     isServizioCorrelato = true;
  2664.                 } catch (DriverRegistroServiziAzioneNotFound e) {
  2665.                     boolean throwFault = true;
  2666.                     if(corsTrasparente) {
  2667.                         try {
  2668.                             infoServizio = registroServiziReader.getInfoServizioCorrelato(soggettoFruitore,idServizio, nomeRegistroForSearch, false, requestInfo);
  2669.                             isServizioCorrelato = true;
  2670.                             throwFault = false;
  2671.                         }catch(Throwable ignore) {
  2672.                             // ignore
  2673.                         }
  2674.                     }
  2675.                     if(throwFault) {
  2676.                         invocazioneAzioneErrata = e.getMessage();
  2677.                         throw e;
  2678.                     }
  2679.                 } catch (DriverRegistroServiziNotFound e) {
  2680.                     erroreRicerca = "\nRicerca come servizio correlato-> "+ e.getMessage();
  2681.                 }

  2683.                 // Ricerca come servizio e azione correlata se ho un profilo
  2684.                 // asincrono asimmetrico (check del profilo interno al metodo)
  2685.                 if (infoServizio == null && (idServizio.getAzione() != null)) {
  2686.                     msgDiag.mediumDebug("Ricerca servizio con azione correlata...");
  2687.                     try {
  2688.                         infoServizio = registroServiziReader.getInfoServizioAzioneCorrelata(soggettoFruitore, idServizio,nomeRegistroForSearch, true, requestInfo);
  2689.                         isServizioCorrelato = true;
  2690.                     } catch (DriverRegistroServiziAzioneNotFound e) {
  2691.                         boolean throwFault = true;
  2692.                         if(corsTrasparente) {
  2693.                             try {
  2694.                                 infoServizio = registroServiziReader.getInfoServizioAzioneCorrelata(soggettoFruitore, idServizio,nomeRegistroForSearch, false, requestInfo);
  2695.                                 isServizioCorrelato = true;
  2696.                                 throwFault = false;
  2697.                             }catch(Throwable ignore) {
  2698.                                 // ignore
  2699.                             }
  2700.                         }
  2701.                         if(throwFault) {
  2702.                             invocazioneAzioneErrata = e.getMessage();
  2703.                             throw e;
  2704.                         }
  2705.                     } catch (DriverRegistroServiziNotFound e) {
  2706.                         erroreRicerca = erroreRicerca+ "\nRicerca come servizio correlato -> "+ e.getMessage();
  2707.                     }
  2708.                 }

  2710.                 // Se non trovato genero errore
  2711.                 msgDiag.highDebug("Controllo dati individuati ...");
  2712.                 if (infoServizio == null && erroreRicerca == null)
  2713.                     throw new DriverRegistroServiziNotFound(
  2714.                             "Servizio Correlato non trovato ne tramite la normale ricerca, ne tramite la ricerca per azione correlata (solo se profilo e' asincrono asimmetrico)");
  2715.                 else if (infoServizio == null)
  2716.                     throw new DriverRegistroServiziNotFound(erroreRicerca);

  2718.             }

  2720.             // RiferimentoServizioCorrelato non presente: cerco sia come
  2721.             // servizio, che casomai come servizio correlato.
  2722.             else {
  2723.                 String erroreRicerca = null;

  2725.                 // Ricerca come servizio
  2726.                 msgDiag.mediumDebug("Ricerca servizio ...");
  2727.                 try {
  2728.                     infoServizio = registroServiziReader.getInfoServizio(soggettoFruitore, idServizio,nomeRegistroForSearch,true, true, requestInfo);
  2729.                 } catch (DriverRegistroServiziAzioneNotFound e) {
  2730.                     boolean throwFault = true;
  2731.                     if(corsTrasparente) {
  2732.                         try {
  2733.                             infoServizio = registroServiziReader.getInfoServizio(soggettoFruitore, idServizio,nomeRegistroForSearch,true, false, requestInfo);
  2734.                             throwFault = false;
  2735.                         }catch(Throwable ignore) {
  2736.                             // ignore
  2737.                         }
  2738.                     }
  2739.                     if(throwFault) {
  2740.                         invocazioneAzioneErrata = e.getMessage();
  2741.                         throw e;
  2742.                     }
  2743.                 } catch (DriverRegistroServiziNotFound e) {
  2744.                     erroreRicerca = "\nRicerca come servizio -> "+ e.getMessage();
  2745.                 }

  2747.                 // Ricerca come servizio correlato
  2748.                 if (infoServizio == null) {
  2749.                     msgDiag.mediumDebug("Ricerca servizio correlato...");
  2750.                     try {
  2751.                         infoServizio = registroServiziReader.getInfoServizioCorrelato(soggettoFruitore,idServizio, nomeRegistroForSearch, true, requestInfo);
  2752.                         isServizioCorrelato = true;
  2753.                     } catch (DriverRegistroServiziAzioneNotFound e) {
  2754.                         boolean throwFault = true;
  2755.                         if(corsTrasparente) {
  2756.                             try {
  2757.                                 infoServizio = registroServiziReader.getInfoServizioCorrelato(soggettoFruitore,idServizio, nomeRegistroForSearch, false, requestInfo);
  2758.                                 isServizioCorrelato = true;
  2759.                                 throwFault = false;
  2760.                             }catch(Throwable ignore) {
  2761.                                 // ignore
  2762.                             }
  2763.                         }
  2764.                         if(throwFault) {
  2765.                             invocazioneAzioneErrata = e.getMessage();
  2766.                             throw e;
  2767.                         }
  2768.                     } catch (DriverRegistroServiziNotFound e) {
  2769.                         erroreRicerca = erroreRicerca+ "\nRicerca come servizio correlato -> "+ e.getMessage();
  2770.                     }
  2771.                 }

  2773.                 // Se non trovato genero errore
  2774.                 if (infoServizio == null && erroreRicerca == null)
  2775.                     throw new DriverRegistroServiziNotFound(
  2776.                             "Servizio non trovato ne tramite la normale ricerca, ne tramite la ricerca per servizio correlato");
  2777.                 else if (infoServizio == null)
  2778.                     throw new DriverRegistroServiziNotFound(erroreRicerca);

  2780.             }
  2781.         } catch (DriverRegistroServiziNotFound e) {
  2782.             eServiceNotFound = e;
  2783.             msgDiag.addKeywordErroreProcessamento(e);
  2784.             msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_IMBUSTAMENTO,"registroServizi.ricercaServizioFallita");
  2785.             servizioNonTrovato = true;
  2786.         } catch (DriverRegistroServiziAzioneNotFound e) {
  2787.             eServiceNotFound = e;
  2788.             msgDiag.addKeywordErroreProcessamento(e);
  2789.             msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_IMBUSTAMENTO,"registroServizi.ricercaServizioFallita");
  2790.             // viene impostata la variabile invocazioneAzioneErrata
  2791.         } catch (DriverRegistroServiziPortTypeNotFound e) {
  2792.             eServiceNotFound = e;
  2793.             msgDiag.addKeywordErroreProcessamento(e,"configurazione registro dei servizi errata");
  2794.             msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_IMBUSTAMENTO,"registroServizi.ricercaServizioFallita");
  2795.             portTypeErrato = "Configurazione del registro dei Servizi errata: "+ e.getMessage();
  2796.         } catch(DriverRegistroServiziCorrelatoNotFound e){
  2797.             eServiceNotFound = e;
  2798.             msgDiag.addKeywordErroreProcessamento(e,"correlazione asincrona non rilevata");
  2799.             msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_IMBUSTAMENTO,"registroServizi.ricercaServizioFallita");
  2800.             servizioCorrelatoNonTrovato = true;
  2801.         } 
  2802.         catch (Exception e) {
  2803.             eServiceNotFound = e;
  2804.             msgDiag.addKeywordErroreProcessamento(e,"errore generale");
  2805.             msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_IMBUSTAMENTO,"registroServizi.ricercaServizioFallita");
  2806.             logError(logCore, "Ricerca servizio fallita",e);
  2807.             ricercaConErrore = true;
  2808.         }

  2810.         // Segnalo eventuali errori di servizio non trovato / errato
  2811.         if (infoServizio == null) {
  2812.             if (servizioNonTrovato == false && ricercaConErrore == false && servizioCorrelatoNonTrovato==false && invocazioneAzioneErrata == null) {
  2813.                 msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO , "servizio non esistente" );
  2814.                 msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_IMBUSTAMENTO,"registroServizi.ricercaServizioFallita");
  2815.                 servizioNonTrovato = true;
  2816.             }
  2817.             ErroreIntegrazione erroreIntegrazione = null;
  2818.             IntegrationFunctionError integrationFunctionError = null;
  2819.             if (invocazioneAzioneErrata != null) {
  2820.                 
  2821.                 String azione = "";
  2822.                 if(idServizio.getAzione()!=null) {
  2823.                     azione = "(azione:"+ idServizio.getAzione()+ ") ";
  2824.                 }
  2825.                 
  2826.                 pddContext.addObject(org.openspcoop2.core.constants.Costanti.OPERAZIONE_NON_INDIVIDUATA, "true");
  2827.                 
  2828.                 erroreIntegrazione = ErroriIntegrazione.ERRORE_423_SERVIZIO_CON_AZIONE_SCORRETTA.
  2829.                         getErrore423_ServizioConAzioneScorretta(azione+ invocazioneAzioneErrata);
  2830.                 integrationFunctionError = IntegrationFunctionError.OPERATION_UNDEFINED;
  2831.             } else if (portTypeErrato != null) {
  2832.                 erroreIntegrazione = ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  2833.                         get5XX_ErroreProcessamento(portTypeErrato, CodiceErroreIntegrazione.CODICE_540_REGISTRO_SERVIZI_MAL_CONFIGURATO);
  2834.                 integrationFunctionError = IntegrationFunctionError.INTERNAL_REQUEST_ERROR;
  2835.             } else if (servizioNonTrovato) {
  2836.                 erroreIntegrazione = ErroriIntegrazione.ERRORE_405_SERVIZIO_NON_TROVATO.getErroreIntegrazione();
  2837.                 integrationFunctionError = IntegrationFunctionError.NOT_FOUND;
  2838.             } else if (ricercaConErrore) {
  2839.                 erroreIntegrazione = ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  2840.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_534_REGISTRO_DEI_SERVIZI_NON_DISPONIBILE);
  2841.                 integrationFunctionError = IntegrationFunctionError.INTERNAL_REQUEST_ERROR;
  2842.             } else if (servizioCorrelatoNonTrovato){
  2843.                 erroreIntegrazione = ErroriIntegrazione.ERRORE_408_SERVIZIO_CORRELATO_NON_TROVATO.getErroreIntegrazione();
  2844.                 //integrationFunctionError = IntegrationFunctionError.CORRELATION_INFORMATION_NOT_FOUND; in questo caso si tratta di un errore nella configurazione
  2845.                 integrationFunctionError = IntegrationFunctionError.INTERNAL_REQUEST_ERROR;
  2846.             } 
  2847.             else {
  2848.                 erroreIntegrazione = ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  2849.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_500_ERRORE_INTERNO);
  2850.                 integrationFunctionError = IntegrationFunctionError.INTERNAL_REQUEST_ERROR;
  2851.             }
  2852.             openspcoopstate.releaseResource();
  2853.             if (this.msgContext.isGestioneRisposta()) {
  2854.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,integrationFunctionError,erroreIntegrazione,eServiceNotFound,null)));
  2855.             }
  2856.             return;
  2857.         }
  2858.         msgDiag.highDebug("Ricerca servizio terminata");
  2859.         infoServizio.setCorrelato(isServizioCorrelato);
  2860.         this.msgContext.getProtocol().setProfiloCollaborazione(infoServizio.getProfiloDiCollaborazione(),null); // il valore verra' serializzato solo successivamente nella busta
  2861.         msgDiag.addKeyword(CostantiPdD.KEY_PROFILO_COLLABORAZIONE, traduttore.toString(infoServizio.getProfiloDiCollaborazione()));
  2862.         if(infoServizio!=null && infoServizio.getIdAccordo()!=null){
  2863.             this.msgContext.getProtocol().setIdAccordo(infoServizio.getIdAccordo());
  2864.             richiestaDelegata.setIdAccordo(infoServizio.getIdAccordo());
  2865.             try{
  2866.                 idServizio.setUriAccordoServizioParteComune(IDAccordoFactory.getInstance().getUriFromIDAccordo(infoServizio.getIdAccordo()));
  2867.             }catch(Exception e){
  2868.                 // ignore
  2869.             }
  2870.         }
  2871.         msgDiag.highDebug("Convert infoServizio to Busta ...");
  2872.         Busta bustaRichiesta = infoServizio.convertToBusta(protocolFactory.getProtocol(), soggettoFruitore);
  2873.         if(sa!=null) {
  2874.             bustaRichiesta.setServizioApplicativoFruitore(sa.getNome());
  2875.         }
  2876.         msgDiag.highDebug("Convert infoServizio to Busta terminata");
  2877.         inRequestPDMessage.setBustaRichiesta(bustaRichiesta);
  2878.         
  2879.         // Aggiorno eventuale valore dipendete dal profilo (PDC)
  2880.         if(this.msgContext.getProtocol()!=null && idServizio.getVersione()!=null) {
  2881.             if(this.msgContext.getProtocol().getVersioneServizio()==null) {
  2882.                 this.msgContext.getProtocol().setVersioneServizio(idServizio.getVersione());
  2883.             }
  2884.             else if(this.msgContext.getProtocol().getVersioneServizio().intValue()!=idServizio.getVersione().intValue()) {
  2885.                 this.msgContext.getProtocol().setVersioneServizio(idServizio.getVersione());
  2886.             }
  2887.         }
  2888.         

  2890.         
  2891.         
  2892.         
  2893.         
  2894.         
  2895.         
  2896.         /* ------------ Autorizzazione ------------- */
  2897.         
  2898.         String tipoAutorizzazione = null;
  2899.         String tipoAutorizzazioneContenuto = null;
  2900.         try {
  2901.             tipoAutorizzazione = configurazionePdDReader.getAutorizzazione(portaDelegata);
  2902.             tipoAutorizzazioneContenuto = configurazionePdDReader.getAutorizzazioneContenuto(portaDelegata);
  2903.         } catch (Exception e) {
  2904.             msgDiag.logErroreGenerico(e, "letturaAutenticazioneTokenAutorizzazione");
  2905.             logError(logCore, msgDiag.getMessaggio_replaceKeywords("letturaAutenticazioneTokenAutorizzazione"),e);
  2906.             openspcoopstate.releaseResource();
  2907.             if (this.msgContext.isGestioneRisposta()) {
  2908.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_REQUEST_ERROR,
  2909.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  2910.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE), e,null)));
  2911.             }
  2912.             return;
  2913.         }
  2914.         
  2915.         DatiInvocazionePortaDelegata datiInvocazione = new DatiInvocazionePortaDelegata();
  2916.         datiInvocazione.setBusta(bustaRichiesta);
  2917.         datiInvocazione.setToken(token);
  2918.         datiInvocazione.setPddContext(pddContext);
  2919.         datiInvocazione.setInfoConnettoreIngresso(inRequestContext.getConnettore());
  2920.         datiInvocazione.setIdServizio(richiestaDelegata.getIdServizio());
  2921.         datiInvocazione.setState(openspcoopstate.getStatoRichiesta());
  2922.         datiInvocazione.setIdPD(identificativoPortaDelegata);
  2923.         datiInvocazione.setPd(portaDelegata);       
  2924.         datiInvocazione.setIdServizioApplicativo(idServizioApplicativo);
  2925.         datiInvocazione.setServizioApplicativo(sa);
  2926.         
  2927.         
  2928.         Utilities.printFreeMemory("RicezioneContenutiApplicativi - Autorizzazione del servizio applicativo...");
  2929.         

  2931.         msgDiag.mediumDebug("Autorizzazione del servizio applicativo...");
  2932.         this.msgContext.getIntegrazione().setTipoAutorizzazione(tipoAutorizzazione);
  2933.         if(tipoAutorizzazione!=null){
  2934.             msgDiag.addKeyword(CostantiPdD.KEY_TIPO_AUTORIZZAZIONE, tipoAutorizzazione);
  2935.         }
  2936.         if (CostantiConfigurazione.AUTORIZZAZIONE_NONE.equalsIgnoreCase(tipoAutorizzazione) == false) {
  2937.             
  2938.             transaction.getTempiElaborazione().startAutorizzazione();
  2939.             try {
  2940.             
  2941.                 msgDiag.logPersonalizzato("autorizzazioneInCorso");
  2942.                 
  2943.                 ErroreIntegrazione errore = null;
  2944.                 Exception eAutorizzazione = null;
  2945.                 OpenSPCoop2Message errorMessageAutorizzazione = null;
  2946.                 String wwwAuthenticateErrorHeader = null;
  2947.                 boolean detailsSet = false;
  2948.                 IntegrationFunctionError integrationFunctionError = null;
  2949.                 try {                       
  2950.                     EsitoAutorizzazionePortaDelegata esito = 
  2951.                             GestoreAutorizzazione.verificaAutorizzazionePortaDelegata(tipoAutorizzazione, datiInvocazione, pddContext, protocolFactory, requestMessage, logCore); 
  2952.                     CostantiPdD.addKeywordInCache(msgDiag, esito.isEsitoPresenteInCache(),
  2953.                             pddContext, CostantiPdD.KEY_INFO_IN_CACHE_FUNZIONE_AUTORIZZAZIONE);
  2954.                     if(esito.getDetails()==null){
  2955.                         msgDiag.addKeyword(CostantiPdD.KEY_DETAILS, "");
  2956.                     }else{
  2957.                         msgDiag.addKeyword(CostantiPdD.KEY_DETAILS, " ("+esito.getDetails()+")");
  2958.                     }
  2959.                     detailsSet = true;
  2960.                     if (esito.isAutorizzato() == false) {
  2961.                         errore = esito.getErroreIntegrazione();
  2962.                         eAutorizzazione = esito.getEccezioneProcessamento();
  2963.                         errorMessageAutorizzazione = esito.getErrorMessage();
  2964.                         wwwAuthenticateErrorHeader = esito.getWwwAuthenticateErrorHeader();
  2965.                         integrationFunctionError = esito.getIntegrationFunctionError();
  2966.                         pddContext.addObject(org.openspcoop2.core.constants.Costanti.ERRORE_AUTORIZZAZIONE, "true");
  2967.                     }
  2968.                     else{
  2969.                         msgDiag.logPersonalizzato("autorizzazioneEffettuata");
  2970.                     }
  2971.                     
  2972.                 } catch (Exception e) {
  2973.                     CostantiPdD.addKeywordInCache(msgDiag, false,
  2974.                             pddContext, CostantiPdD.KEY_INFO_IN_CACHE_FUNZIONE_AUTORIZZAZIONE);
  2975.                     errore = ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  2976.                             get5XX_ErroreProcessamento("processo di autorizzazione ["
  2977.                                     + tipoAutorizzazione + "] fallito, " + e.getMessage(),CodiceErroreIntegrazione.CODICE_504_AUTORIZZAZIONE);
  2978.                     eAutorizzazione = e;
  2979.                     logError(logCore, "processo di autorizzazione ["
  2980.                             + tipoAutorizzazione + "] fallito, " + e.getMessage(),e);
  2981.                 }
  2982.                 if (errore != null) {
  2983.                     if(!detailsSet) {
  2984.                         msgDiag.addKeyword(CostantiPdD.KEY_DETAILS, "");
  2985.                     }
  2986.                     String descrizioneErrore = null;
  2987.                     try{
  2988.                         descrizioneErrore = errore.getDescrizione(protocolFactory);
  2989.                         msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, descrizioneErrore);
  2990.                     }catch(Exception e){
  2991.                         logError(logCore, "getDescrizione Error:"+e.getMessage(),e);
  2992.                     }
  2993.                     msgDiag.logPersonalizzato("servizioApplicativoFruitore.nonAutorizzato");
  2994.                     String errorMsg =  "Riscontrato errore durante il processo di Autorizzazione per il messaggio con identificativo ["+idMessageRequest+"]: "+descrizioneErrore;
  2995.                     if(eAutorizzazione!=null){
  2996.                         logError(logCore, errorMsg,eAutorizzazione);
  2997.                     }
  2998.                     else{
  2999.                         logError(logCore, errorMsg);
  3000.                     }
  3001.                     openspcoopstate.releaseResource();
  3002.     
  3003.                     if (this.msgContext.isGestioneRisposta()) {
  3004.                         
  3005.                         if(errorMessageAutorizzazione!=null) {
  3006.                             this.msgContext.setMessageResponse(errorMessageAutorizzazione);
  3007.                         }
  3008.                         else {
  3009.                         
  3010.                             if(CodiceErroreIntegrazione.CODICE_404_AUTORIZZAZIONE_FALLITA.equals(errore.getCodiceErrore()) ||
  3011.                                     CodiceErroreIntegrazione.CODICE_445_TOKEN_AUTORIZZAZIONE_FALLITA.equals(errore.getCodiceErrore())){
  3012.                                 if(integrationFunctionError==null) {
  3013.                                     integrationFunctionError = IntegrationFunctionError.AUTHORIZATION;
  3014.                                 }
  3015.                             }else{
  3016.                                 if(integrationFunctionError==null) {
  3017.                                     integrationFunctionError = IntegrationFunctionError.INTERNAL_REQUEST_ERROR;
  3018.                                 }
  3019.                             }
  3020.                             
  3021.                             OpenSPCoop2Message errorOpenSPCoopMsg = (this.generatoreErrore.build(pddContext,integrationFunctionError,errore,
  3022.                                     eAutorizzazione,null));
  3023.     
  3024.                             if(wwwAuthenticateErrorHeader!=null) {
  3025.                                 errorOpenSPCoopMsg.forceTransportHeader(HttpConstants.AUTHORIZATION_RESPONSE_WWW_AUTHENTICATE, wwwAuthenticateErrorHeader);
  3026.                             }
  3027.                             
  3028.                             this.msgContext.setMessageResponse(errorOpenSPCoopMsg);
  3029.                             
  3030.                         }
  3031.                     }
  3032.                     return;
  3033.                 }
  3034.             }finally {
  3035.                 transaction.getTempiElaborazione().endAutorizzazione();
  3036.             }
  3037.         }
  3038.         else{
  3039.             msgDiag.logPersonalizzato("autorizzazioneDisabilitata");
  3040.         }
  3041.         
  3042.         
  3043.         
  3044.         
  3045.         
  3046.         
  3047.         
  3048.         
  3049.     
  3050.         
  3051.         
  3052.         
  3053.         /* -------- Controlli Header di Integrazione ------------- */
  3054.         
  3055.         if(infoServizio.getIdRiferimentoRichiesta() &&
  3056.                 protocolConfig.isIntegrationInfoRequired(TipoPdD.DELEGATA, requestInfo.getProtocolServiceBinding(),FunzionalitaProtocollo.RIFERIMENTO_ID_RICHIESTA)) {
  3057.             String riferimentoRichiesta = null;
  3058.             if (headerIntegrazioneRichiesta!=null &&
  3059.                     headerIntegrazioneRichiesta.getBusta() != null && headerIntegrazioneRichiesta.getBusta().getRiferimentoMessaggio() != null) {
  3060.                 riferimentoRichiesta = headerIntegrazioneRichiesta.getBusta().getRiferimentoMessaggio();
  3061.                 this.msgContext.getProtocol().setRiferimentoAsincrono(riferimentoRichiesta);
  3062.             }
  3063.             if(riferimentoRichiesta==null) {
  3064.                 StringBuilder bf = new StringBuilder();
  3065.                 for (int i = 0; i < tipiIntegrazionePD.length; i++) {
  3066.                     if(i>0) {
  3067.                         bf.append(",");
  3068.                     }
  3069.                     bf.append(tipiIntegrazionePD[i]);
  3070.                 }
  3071.                 msgDiag.addKeyword(CostantiPdD.KEY_TIPI_INTEGRAZIONE ,bf.toString() );
  3072.                 msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_RICEZIONE_CONTENUTI_APPLICATIVI,"riferimentoIdRichiesta.nonFornito");
  3073.                 ErroreIntegrazione erroreIntegrazione = ErroriIntegrazione.ERRORE_442_RIFERIMENTO_ID_MESSAGGIO.getErroreIntegrazione();
  3074.                 IntegrationFunctionError integrationFunctionError = IntegrationFunctionError.CORRELATION_INFORMATION_NOT_FOUND;
  3075.                 
  3076.                 openspcoopstate.releaseResource();
  3077.                 if (this.msgContext.isGestioneRisposta()) {
  3078.                     this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,integrationFunctionError,erroreIntegrazione,null,null)));
  3079.                 }
  3080.                 return;
  3081.                 
  3082.             }
  3083.         }
  3084.         
  3085.         
  3086.         
  3087.         
  3088.         
  3089.         /* -------- Profilo di Gestione ------------- */
  3090.         try {
  3091.             String profiloGestione = registroServiziReader.getProfiloGestioneFruizioneServizio(idServizio,nomeRegistroForSearch, requestInfo);
  3092.             richiestaDelegata.setProfiloGestione(profiloGestione);
  3093.             msgDiag.mediumDebug("Profilo di gestione ["+ RicezioneContenutiApplicativi.ID_MODULO+ "] della busta: " + profiloGestione);
  3094.         } catch (Exception e) {
  3095.             msgDiag.addKeywordErroreProcessamento(e,"analisi del profilo di gestione fallita");
  3096.             msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_IMBUSTAMENTO,"registroServizi.ricercaServizioFallita");
  3097.             logError(logCore, "Identificazione Profilo Gestione fallita",e);
  3098.             openspcoopstate.releaseResource();
  3099.             if (this.msgContext.isGestioneRisposta()) {
  3100.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_REQUEST_ERROR,
  3101.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  3102.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_525_GESTIONE_FUNZIONALITA_PROTOCOLLO),e,null)));
  3103.             }
  3104.             return;
  3105.         }
  3106.         
  3107.         
  3108.         
  3109.         
  3110.         /* -------- OpenSPCoop2Message Update ------------- */
  3111.         try {
  3112.             msgDiag.mediumDebug("Aggiornamento del messaggio");
  3113.             requestMessage = protocolFactory.createProtocolManager().updateOpenSPCoop2MessageRequest(requestMessage, bustaRichiesta,
  3114.                     protocolFactory.getCachedRegistryReader(registroServiziReader, requestInfo));
  3115.         } catch (Exception e) {
  3116.             msgDiag.addKeywordErroreProcessamento(e,"Aggiornamento messaggio fallito");
  3117.             msgDiag.logErroreGenerico(e,"ProtocolManager.updateOpenSPCoop2Message");
  3118.             logError(logCore, "ProtocolManager.updateOpenSPCoop2Message error: "+e.getMessage(),e);
  3119.             openspcoopstate.releaseResource();
  3120.             if (this.msgContext.isGestioneRisposta()) {
  3121.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_REQUEST_ERROR,
  3122.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  3123.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_525_GESTIONE_FUNZIONALITA_PROTOCOLLO),e,null)));
  3124.             }
  3125.             return;
  3126.         }
  3127.         
  3128.         
  3129.         
  3130.         
  3131.         /* -------- Indirizzi Risposta  ------------- */
  3132.         
  3133.         String indirizzoFruitore = null;
  3134.         String indirizzoErogatore = null;
  3135.         IProtocolConfiguration protocolConfiguration = protocolFactory.createProtocolConfiguration();
  3136.         if(protocolConfiguration.isSupportoIndirizzoRisposta()){
  3137.             try {
  3138.                 Connettore connettoreFruitore = null;
  3139.                 try{
  3140.                     connettoreFruitore = registroServiziReader.getConnettore(soggettoFruitore, nomeRegistroForSearch, requestInfo);
  3141.                 }catch(org.openspcoop2.core.registry.driver.DriverRegistroServiziNotFound dNotFound){
  3142.                     // ignore
  3143.                 }
  3144.                 if(connettoreFruitore!=null && !CostantiConfigurazione.DISABILITATO.equals(connettoreFruitore.getTipo())){
  3145.                     if(connettoreFruitore.getProperties()!=null && connettoreFruitore.getProperties().containsKey(CostantiConnettori.CONNETTORE_LOCATION)){
  3146.                         indirizzoFruitore = connettoreFruitore.getProperties().get(CostantiConnettori.CONNETTORE_LOCATION);
  3147.                     }
  3148.                 }
  3149.                 msgDiag.mediumDebug("Indirizzo Risposta del soggetto fruitore ["+ soggettoFruitore+ "]: " + indirizzoFruitore);
  3150.                 
  3151.                 Connettore connettoreErogatore = null;
  3152.                 try{
  3153.                     connettoreErogatore = registroServiziReader.getConnettore(idServizio.getSoggettoErogatore(), nomeRegistroForSearch, requestInfo);
  3154.                 }catch(org.openspcoop2.core.registry.driver.DriverRegistroServiziNotFound dNotFound){
  3155.                     // ignore
  3156.                 }
  3157.                 if(connettoreErogatore!=null && !CostantiConfigurazione.DISABILITATO.equals(connettoreErogatore.getTipo())){
  3158.                     if(connettoreErogatore.getProperties()!=null && connettoreErogatore.getProperties().containsKey(CostantiConnettori.CONNETTORE_LOCATION)){
  3159.                         indirizzoErogatore = connettoreErogatore.getProperties().get(CostantiConnettori.CONNETTORE_LOCATION);
  3160.                     }
  3161.                 }
  3162.                 msgDiag.mediumDebug("Indirizzo Risposta del soggetto erogatore ["+ idServizio.getSoggettoErogatore()+ "]: " + indirizzoErogatore);
  3163.                 
  3164.             } catch (Exception e) {
  3165.                 msgDiag.addKeywordErroreProcessamento(e,"recupero degli indirizzi di risposta per i soggetti fallita");
  3166.                 msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_IMBUSTAMENTO,"registroServizi.ricercaServizioFallita");
  3167.                 logError(logCore, "Identificazione Indirizzo Risposta fallita",e);
  3168.                 openspcoopstate.releaseResource();
  3169.                 if (this.msgContext.isGestioneRisposta()) {
  3170.                     this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_REQUEST_ERROR,
  3171.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  3172.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_525_GESTIONE_FUNZIONALITA_PROTOCOLLO),e,null)));
  3173.                 }
  3174.                 return;
  3175.             }
  3176.             this.msgContext.getProtocol().setIndirizzoFruitore(indirizzoFruitore);
  3177.             this.msgContext.getProtocol().setIndirizzoErogatore(indirizzoErogatore);
  3178.         }
  3179.         
  3180.         
  3181.         /* ---- Ricerca registro dei servizi terminata con successo --- */
  3182.         msgDiag.logPersonalizzato(MsgDiagnosticiProperties.MSG_DIAG_IMBUSTAMENTO,"registroServizi.ricercaServizioEffettuata");
  3183.         
  3184.         
  3185.         

  3187.         
  3188.         
  3189.         
  3190.         
  3191.         
  3192.         
  3193.         
  3194.         
  3195.         
  3196.         
  3197.         
  3198.         
  3199.         
  3200.         
  3201.         // ------------- in-protocol-handler -----------------------------
  3202.         try{
  3203.             InRequestProtocolContext inRequestProtocolContext = new InRequestProtocolContext(inRequestContext);
  3204.             if(inRequestProtocolContext.getStato()==null) {
  3205.                 inRequestProtocolContext.setStato(openspcoopstate.getStatoRichiesta());
  3206.             }
  3207.             if(inRequestProtocolContext.getConnettore()!=null){
  3208.                 inRequestProtocolContext.getConnettore().setCredenziali(credenziali);
  3209.             }
  3210.             inRequestProtocolContext.setProtocollo(this.msgContext.getProtocol());
  3211.             inRequestProtocolContext.setIntegrazione(this.msgContext.getIntegrazione());
  3212.             GestoreHandlers.inRequestProtocol(inRequestProtocolContext, msgDiag, logCore);
  3213.         }catch(Exception e){        
  3214.             ErroreIntegrazione erroreIntegrazione = null;
  3215.             IntegrationFunctionError integrationFunctionError = null; 
  3216.             if(e instanceof HandlerException){
  3217.                 HandlerException he = (HandlerException) e;
  3218.                 if(he.isEmettiDiagnostico()){
  3219.                     msgDiag.logErroreGenerico(e,he.getIdentitaHandler());
  3220.                 }
  3221.                 logError(logCore, "Gestione InRequestProtocolHandler non riuscita ("+he.getIdentitaHandler()+"): "  + he);
  3222.                 if(this.msgContext.isGestioneRisposta()){
  3223.                     erroreIntegrazione = he.convertToErroreIntegrazione();
  3224.                     integrationFunctionError = he.getIntegrationFunctionError();
  3225.                 }
  3226.             }else{
  3227.                 msgDiag.logErroreGenerico(e,"InvocazioneInRequestHandler");
  3228.                 logError(logCore, "Gestione InRequestProtocolHandler non riuscita: "    + e);
  3229.             }
  3230.             openspcoopstate.releaseResource();
  3231.             if (this.msgContext.isGestioneRisposta()) {
  3232.                 if(erroreIntegrazione==null){
  3233.                     erroreIntegrazione = ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  3234.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_558_HANDLER_IN_PROTOCOL_REQUEST);
  3235.                 }
  3236.                 if(integrationFunctionError==null) {
  3237.                     integrationFunctionError = IntegrationFunctionError.INTERNAL_REQUEST_ERROR;
  3238.                 }
  3239.                 OpenSPCoop2Message responseMessageError = this.generatoreErrore.build(pddContext,integrationFunctionError,erroreIntegrazione,e,null);
  3240.                 if(e instanceof HandlerException){
  3241.                     HandlerException he = (HandlerException) e;
  3242.                     he.customized(responseMessageError);
  3243.                 }
  3244.                 this.msgContext.setMessageResponse(responseMessageError);
  3245.             }
  3246.             return;
  3247.         }
  3248.         
  3249.         
  3250.         
  3251.         
  3252.         
  3253.         
  3254.         
  3255.         
  3256.         
  3257.         
  3258.         
  3259.         
  3260.         
  3261.         /* -------------------------- Implementazione PdD Soggetti busta -------------------------------*/
  3262.         String implementazionePdDMittente = null;
  3263.         String implementazionePdDDestinatario = null;
  3264.         String idPdDMittente = null;
  3265.         String idPdDDestinatario = null;
  3266.         msgDiag.mediumDebug("Ricerca implementazione della porta di dominio dei soggetti...");
  3267.         try{
  3268.             implementazionePdDMittente = registroServiziReader.getImplementazionePdD(soggettoFruitore, null, requestInfo);
  3269.             implementazionePdDDestinatario = registroServiziReader.getImplementazionePdD(idServizio.getSoggettoErogatore(), null, requestInfo);
  3270.             idPdDMittente = registroServiziReader.getIdPortaDominio(soggettoFruitore, null, requestInfo);
  3271.             idPdDDestinatario = registroServiziReader.getIdPortaDominio(idServizio.getSoggettoErogatore(), null, requestInfo);
  3272.         }catch(Exception e){
  3273.             msgDiag.logErroreGenerico(e,"ricercaImplementazioniPdD");
  3274.             openspcoopstate.releaseResource();
  3275.             if (this.msgContext.isGestioneRisposta()) {
  3276.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_REQUEST_ERROR,
  3277.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  3278.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_534_REGISTRO_DEI_SERVIZI_NON_DISPONIBILE),e,null)));
  3279.             }
  3280.             return;
  3281.         }
  3282.         msgDiag.mediumDebug("ImplementazionePdD soggetto ("+soggettoFruitore.toString()+") e' ["+implementazionePdDMittente+"], soggetto ("
  3283.                 +idServizio.getSoggettoErogatore().toString()+") e' ["+implementazionePdDDestinatario+"]");
  3284.         
  3285.         
  3286.         
  3287.         Utilities.printFreeMemory("RicezioneContenutiApplicativi - Controllo validazione xsd abilitata/disabilitata...");
  3288.         
  3289.         
  3290.         
  3291.         /* ------------ Validazione Contenuti Applicativi ------------- */
  3292.         msgDiag.mediumDebug("Controllo validazione xsd abilitata/disabilitata...");
  3293.         ValidazioneContenutiApplicativi validazioneContenutoApplicativoApplicativo = null;
  3294.         List<Proprieta> proprietaPorta = null;
  3295.         try {
  3296.             validazioneContenutoApplicativoApplicativo = configurazionePdDReader.getTipoValidazioneContenutoApplicativo(portaDelegata,implementazionePdDDestinatario, true);
  3297.             proprietaPorta = portaDelegata.getProprietaList();
  3298.         } catch (Exception e) {
  3299.             msgDiag.logErroreGenerico(e,"getTipoValidazioneContenutoApplicativo(pd,"+implementazionePdDDestinatario+")");
  3300.             openspcoopstate.releaseResource();
  3301.             if (this.msgContext.isGestioneRisposta()) {
  3302.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_REQUEST_ERROR,
  3303.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  3304.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE),e,null)));
  3305.             }
  3306.             return;
  3307.         }
  3308.         if(validazioneContenutoApplicativoApplicativo!=null && validazioneContenutoApplicativoApplicativo.getTipo()!=null){
  3309.             String tipo = ValidatoreMessaggiApplicativi.getTipo(validazioneContenutoApplicativoApplicativo);
  3310.             this.msgContext.getIntegrazione().setTipoValidazioneContenuti(tipo);
  3311.             msgDiag.addKeyword(CostantiPdD.KEY_TIPO_VALIDAZIONE_CONTENUTI, tipo);
  3312.             msgDiag.addKeyword(CostantiPdD.KEY_DETAILS_VALIDAZIONE_CONTENUTI,"");
  3313.         }
  3314.         if (
  3315.                 (validazioneContenutoApplicativoApplicativo!=null)
  3316.                 &&
  3317.                 (
  3318.                         CostantiConfigurazione.STATO_CON_WARNING_ABILITATO.equals(validazioneContenutoApplicativoApplicativo.getStato())
  3319.                         || 
  3320.                         CostantiConfigurazione.STATO_CON_WARNING_WARNING_ONLY.equals(validazioneContenutoApplicativoApplicativo.getStato())
  3321.                 )
  3322.             ) {

  3324.             transaction.getTempiElaborazione().startValidazioneRichiesta();
  3325.             ByteArrayInputStream binXSD = null;
  3326.             try {
  3327.                 msgDiag.logPersonalizzato("validazioneContenutiApplicativiRichiestaInCorso");
  3328.                 
  3329.                 boolean readInterface = CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_INTERFACE.equals(validazioneContenutoApplicativoApplicativo.getTipo());
  3330.                         
  3331.                 if(ServiceBinding.SOAP.equals(requestMessage.getServiceBinding())){
  3332.                 
  3333.                     // Accept mtom message
  3334.                     List<MtomXomReference> xomReferences = null;
  3335.                     if(StatoFunzionalita.ABILITATO.equals(validazioneContenutoApplicativoApplicativo.getAcceptMtomMessage())){
  3336.                         msgDiag.mediumDebug("Validazione xsd della richiesta (mtomFastUnpackagingForXSDConformance)...");
  3337.                         if(ServiceBinding.SOAP.equals(requestMessage.getServiceBinding())==false){
  3338.                             throw new Exception("Funzionalita 'AcceptMtomMessage' valida solamente per Service Binding SOAP");
  3339.                         }
  3340.                         xomReferences = requestMessage.castAsSoap().mtomFastUnpackagingForXSDConformance();
  3341.                     }
  3342.                     
  3343.                     // Init Validatore
  3344.                     msgDiag.mediumDebug("Validazione xsd della richiesta (initValidator)...");
  3345.                     ValidatoreMessaggiApplicativi validatoreMessaggiApplicativi = new ValidatoreMessaggiApplicativi(
  3346.                             registroServiziReader, richiestaDelegata.getIdServizio(), requestMessage,readInterface,
  3347.                             propertiesReader.isValidazioneContenutiApplicativiRpcLiteralXsiTypeGestione(),
  3348.                             proprietaPorta,
  3349.                             pddContext);
  3350.                 
  3351.                     // Validazione WSDL
  3352.                     if (CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_INTERFACE.equals(validazioneContenutoApplicativoApplicativo.getTipo())
  3353.                         || CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_OPENSPCOOP.equals(validazioneContenutoApplicativoApplicativo.getTipo())) {
  3354.                         msgDiag.mediumDebug("Validazione wsdl della richiesta ...");
  3355.                         validatoreMessaggiApplicativi.validateWithWsdlLogicoImplementativo(true);
  3356.                     }
  3357.                     
  3358.                     // Validazione XSD
  3359.                     msgDiag.mediumDebug("Validazione xsd della richiesta (validazione)...");
  3360.                     validatoreMessaggiApplicativi.validateWithWsdlDefinitorio(true);
  3361.     
  3362.                     // Validazione WSDL (Restore Original Document)
  3363.                     if (CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_INTERFACE.equals(validazioneContenutoApplicativoApplicativo.getTipo())
  3364.                         || CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_OPENSPCOOP.equals(validazioneContenutoApplicativoApplicativo.getTipo())) {
  3365.                         if(propertiesReader.isValidazioneContenutiApplicativiRpcLiteralXsiTypeGestione() &&
  3366.                                 propertiesReader.isValidazioneContenutiApplicativiRpcLiteralXsiTypeRipulituraDopoValidazione()){
  3367.                             msgDiag.mediumDebug("Ripristino elementi modificati per supportare validazione wsdl della richiesta ...");
  3368.                             validatoreMessaggiApplicativi.restoreOriginalDocument(true);
  3369.                         }
  3370.                     }
  3371.                     
  3372.                     // Ripristino struttura messaggio con xom
  3373.                     if(xomReferences!=null && xomReferences.size()>0){
  3374.                         msgDiag.mediumDebug("Validazione xsd della richiesta (mtomRestoreAfterXSDConformance)...");
  3375.                         if(ServiceBinding.SOAP.equals(requestMessage.getServiceBinding())==false){
  3376.                             throw new Exception("Funzionalita 'AcceptMtomMessage' valida solamente per Service Binding SOAP");
  3377.                         }
  3378.                         requestMessage.castAsSoap().mtomRestoreAfterXSDConformance(xomReferences);
  3379.                     }
  3380.                     
  3381.                 }
  3382.                 else {
  3383.                     
  3384.                     // Init Validatore
  3385.                     msgDiag.mediumDebug("Validazione della richiesta (initValidator)...");
  3386.                     ValidatoreMessaggiApplicativiRest validatoreMessaggiApplicativi = 
  3387.                         new ValidatoreMessaggiApplicativiRest(registroServiziReader, richiestaDelegata.getIdServizio(), requestMessage, readInterface, proprietaPorta,
  3388.                                 protocolFactory, pddContext);
  3389.                     
  3390.                     if(CostantiConfigurazione.VALIDAZIONE_CONTENUTI_APPLICATIVI_XSD.equals(validazioneContenutoApplicativoApplicativo.getTipo()) &&
  3391.                             requestMessage.castAsRest().hasContent()) {
  3392.                         
  3393.                         // Validazione XSD
  3394.                         msgDiag.mediumDebug("Validazione xsd della richiesta ...");
  3395.                         validatoreMessaggiApplicativi.validateWithSchemiXSD(true);
  3396.                         
  3397.                     }
  3398.                     else {
  3399.                         
  3400.                         // Validazione Interface
  3401.                         validatoreMessaggiApplicativi.validateRequestWithInterface(false);
  3402.                         
  3403.                     }
  3404.                     
  3405.                 }
  3406.                 
  3407.                 msgDiag.logPersonalizzato("validazioneContenutiApplicativiRichiestaEffettuata");
  3408.                 
  3409.             } catch (ValidatoreMessaggiApplicativiException ex) {
  3410.                 msgDiag.addKeywordErroreProcessamento(ex);
  3411.                 logError(logCore, "[ValidazioneContenutiApplicativi Richiesta] "+ex.getMessage(),ex);
  3412.                 if (CostantiConfigurazione.STATO_CON_WARNING_WARNING_ONLY.equals(validazioneContenutoApplicativoApplicativo.getStato())) {
  3413.                     msgDiag.logPersonalizzato("validazioneContenutiApplicativiRichiestaNonRiuscita.warningOnly");
  3414.                 }
  3415.                 else {
  3416.                     msgDiag.logPersonalizzato("validazioneContenutiApplicativiRichiestaNonRiuscita");
  3417.                 }
  3418.                 if (CostantiConfigurazione.STATO_CON_WARNING_WARNING_ONLY.equals(validazioneContenutoApplicativoApplicativo.getStato()) == false) {
  3419.                     
  3420.                     pddContext.addObject(org.openspcoop2.core.constants.Costanti.ERRORE_VALIDAZIONE_RICHIESTA, "true");
  3421.                     
  3422.                     // validazione abilitata
  3423.                     openspcoopstate.releaseResource();
  3424.                     if (this.msgContext.isGestioneRisposta()) {
  3425.                         IntegrationFunctionError integrationFunctionError = null;
  3426.                         if(ex.getErrore()!=null &&
  3427.                                 (
  3428.                                         //CodiceErroreIntegrazione.CODICE_417_COSTRUZIONE_VALIDATORE_TRAMITE_INTERFACCIA_FALLITA.equals(ex.getErrore().getCodiceErrore()) ||
  3429.                                         CodiceErroreIntegrazione.CODICE_418_VALIDAZIONE_RICHIESTA_TRAMITE_INTERFACCIA_FALLITA.equals(ex.getErrore().getCodiceErrore()) 
  3430.                                 )
  3431.                             ){
  3432.                             integrationFunctionError = IntegrationFunctionError.INVALID_REQUEST_CONTENT;
  3433.                         }
  3434.                         else{
  3435.                             integrationFunctionError = IntegrationFunctionError.INTERNAL_REQUEST_ERROR;
  3436.                         }
  3437.                         this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,integrationFunctionError, ex.getErrore(),ex,null)));
  3438.                     }
  3439.                     return;
  3440.                 }
  3441.             } catch (Exception ex) {
  3442.                 msgDiag.addKeywordErroreProcessamento(ex);
  3443.                 logError(logCore, "Riscontrato errore durante la validazione xsd della richiesta applicativa",ex);
  3444.                 if (CostantiConfigurazione.STATO_CON_WARNING_WARNING_ONLY.equals(validazioneContenutoApplicativoApplicativo.getStato())) {
  3445.                     msgDiag.logPersonalizzato("validazioneContenutiApplicativiRichiestaNonRiuscita.warningOnly");
  3446.                 }
  3447.                 else {
  3448.                     msgDiag.logPersonalizzato("validazioneContenutiApplicativiRichiestaNonRiuscita");
  3449.                 }
  3450.                 if (CostantiConfigurazione.STATO_CON_WARNING_WARNING_ONLY.equals(validazioneContenutoApplicativoApplicativo.getStato()) == false) {
  3451.                     
  3452.                     pddContext.addObject(org.openspcoop2.core.constants.Costanti.ERRORE_VALIDAZIONE_RICHIESTA, "true");
  3453.                     
  3454.                     // validazione abilitata
  3455.                     openspcoopstate.releaseResource();
  3456.                     if (this.msgContext.isGestioneRisposta()) {
  3457.                         this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_REQUEST_ERROR,
  3458.                                 ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  3459.                                 get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_531_VALIDAZIONE_TRAMITE_INTERFACCIA_FALLITA),ex,null)));
  3460.                     }
  3461.                     return;
  3462.                 }
  3463.             } finally {
  3464.                 transaction.getTempiElaborazione().endValidazioneRichiesta();
  3465.                 if (binXSD != null) {
  3466.                     try {
  3467.                         binXSD.close();
  3468.                     } catch (Exception e) {
  3469.                         // ignore
  3470.                     }
  3471.                 }
  3472.             }
  3473.         }
  3474.         else{
  3475.             msgDiag.logPersonalizzato("validazioneContenutiApplicativiRichiestaDisabilitata");
  3476.         }

  3478.         
  3479.         
  3480.         
  3481.         
  3482.         
  3483.         
  3484.         
  3485.         
  3486.         
  3487.         Utilities.printFreeMemory("RicezioneContenutiApplicativi - Autorizzazione del servizio applicativo...");
  3488.         
  3489.         
  3490.         
  3491.         /* ------------ Autorizzazione per Contenuto ------------- */
  3492.         msgDiag.mediumDebug("Autorizzazione del servizio applicativo...");
  3493.         this.msgContext.getIntegrazione().setTipoAutorizzazioneContenuto(tipoAutorizzazioneContenuto);
  3494.         if(tipoAutorizzazioneContenuto!=null){
  3495.             msgDiag.addKeyword(CostantiPdD.KEY_TIPO_AUTORIZZAZIONE_CONTENUTO, tipoAutorizzazioneContenuto);
  3496.         }
  3497.         if (CostantiConfigurazione.AUTORIZZAZIONE_NONE.equalsIgnoreCase(tipoAutorizzazioneContenuto) == false) {
  3498.             
  3499.             transaction.getTempiElaborazione().startAutorizzazioneContenuti();
  3500.             try {
  3501.             
  3502.                 msgDiag.logPersonalizzato("autorizzazioneContenutiApplicativiInCorso");
  3503.                 
  3504.                 ErroreIntegrazione errore = null;
  3505.                 Exception eAutorizzazione = null;
  3506.                 boolean detailsSet = false;
  3507.                 IntegrationFunctionError integrationFunctionError = null;
  3508.                 try {
  3509.                     // Controllo Autorizzazione
  3510.                     EsitoAutorizzazionePortaDelegata esito = 
  3511.                             GestoreAutorizzazione.verificaAutorizzazioneContenutoPortaDelegata(tipoAutorizzazioneContenuto, datiInvocazione, pddContext, protocolFactory, requestMessage, logCore);
  3512.                     CostantiPdD.addKeywordInCache(msgDiag, esito.isEsitoPresenteInCache(),
  3513.                             pddContext, CostantiPdD.KEY_INFO_IN_CACHE_FUNZIONE_AUTORIZZAZIONE_CONTENUTI);
  3514.                     if(esito.getDetails()==null){
  3515.                         msgDiag.addKeyword(CostantiPdD.KEY_DETAILS, "");
  3516.                     }else{
  3517.                         msgDiag.addKeyword(CostantiPdD.KEY_DETAILS, " ("+esito.getDetails()+")");
  3518.                     }
  3519.                     detailsSet = true;
  3520.                     if (esito.isAutorizzato() == false) {
  3521.                         errore = esito.getErroreIntegrazione();
  3522.                         eAutorizzazione = esito.getEccezioneProcessamento();
  3523.                         integrationFunctionError = esito.getIntegrationFunctionError();
  3524.                         pddContext.addObject(org.openspcoop2.core.constants.Costanti.ERRORE_AUTORIZZAZIONE, "true");
  3525.                     }
  3526.                     else{
  3527.                         msgDiag.logPersonalizzato("autorizzazioneContenutiApplicativiEffettuata");
  3528.                     }
  3529.                 } catch (Exception e) {
  3530.                     CostantiPdD.addKeywordInCache(msgDiag, false,
  3531.                             pddContext, CostantiPdD.KEY_INFO_IN_CACHE_FUNZIONE_AUTORIZZAZIONE_CONTENUTI);
  3532.                     String msgErroreAutorizzazione = "processo di autorizzazione ["
  3533.                             + tipoAutorizzazioneContenuto + "] fallito, " + e.getMessage();
  3534.                     errore = ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  3535.                             get5XX_ErroreProcessamento(msgErroreAutorizzazione, CodiceErroreIntegrazione.CODICE_542_AUTORIZZAZIONE_CONTENUTO);
  3536.                     eAutorizzazione = e;
  3537.                     logError(logCore, msgErroreAutorizzazione,e);
  3538.                 }
  3539.                 if (errore != null) {
  3540.                     if(!detailsSet) {
  3541.                         msgDiag.addKeyword(CostantiPdD.KEY_DETAILS, "");
  3542.                     }
  3543.                     msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO, errore.getDescrizione(protocolFactory));
  3544.                     msgDiag.logPersonalizzato("servizioApplicativoFruitore.contenuto.nonAutorizzato");
  3545.                     openspcoopstate.releaseResource();
  3546.     
  3547.                     if (this.msgContext.isGestioneRisposta()) {
  3548.                         if(CodiceErroreIntegrazione.CODICE_404_AUTORIZZAZIONE_FALLITA.equals(errore.getCodiceErrore()) || 
  3549.                                 CodiceErroreIntegrazione.CODICE_428_AUTORIZZAZIONE_CONTENUTO_FALLITA.equals(errore.getCodiceErrore())){
  3550.                             if(integrationFunctionError==null) {
  3551.                                 integrationFunctionError = IntegrationFunctionError.CONTENT_AUTHORIZATION_DENY;
  3552.                             }
  3553.                         }else{
  3554.                             if(integrationFunctionError==null) {
  3555.                                 integrationFunctionError = IntegrationFunctionError.INTERNAL_REQUEST_ERROR;
  3556.                             }
  3557.                         }
  3558.                         this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,integrationFunctionError,errore,
  3559.                                 eAutorizzazione,null)));
  3560.                     }
  3561.                     return;
  3562.                 }
  3563.             }finally {
  3564.                 transaction.getTempiElaborazione().endAutorizzazioneContenuti();
  3565.             }
  3566.         }
  3567.         else{
  3568.             msgDiag.logPersonalizzato("autorizzazioneContenutiApplicativiDisabilitata");
  3569.         }
  3570.         
  3571.         
  3572.         
  3573.         
  3574.         
  3575.         
  3576.         
  3577.         
  3578.         
  3579.         
  3580.         
  3581.         Utilities.printFreeMemory("RicezioneContenutiApplicativi - Controllo tipo di invocazione (riferimento/normale)...");
  3582.         
  3583.         
  3584.         
  3585.         /*
  3586.          * ------------ Check tipo di invocazione PD (x riferimento) -------------
  3587.          */
  3588.         msgDiag.mediumDebug("Controllo tipo di invocazione (riferimento/normale)...");
  3589.         boolean invocazionePDPerRiferimento = false;
  3590.         try {
  3591.             invocazionePDPerRiferimento = configurazionePdDReader.invocazionePortaDelegataPerRiferimento(sa);
  3592.         } catch (Exception e) {
  3593.             msgDiag.logErroreGenerico(e,"invocazionePortaDelegataPerRiferimento(sa)");
  3594.             openspcoopstate.releaseResource();
  3595.             if (this.msgContext.isGestioneRisposta()) {
  3596.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_REQUEST_ERROR,
  3597.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  3598.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE),e,null)));
  3599.             }
  3600.             return;
  3601.         }
  3602.         if (invocazionePDPerRiferimento) {
  3603.             if (this.msgContext.isInvocazionePDPerRiferimento() == false) {
  3604.                 msgDiag.logPersonalizzato("portaDelegataInvocabilePerRiferimento.riferimentoNonPresente");
  3605.                 openspcoopstate.releaseResource();
  3606.                 if (this.msgContext.isGestioneRisposta()) {
  3607.                     this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.BAD_REQUEST,
  3608.                             ErroriIntegrazione.ERRORE_412_PD_INVOCABILE_SOLO_PER_RIFERIMENTO.
  3609.                             getErroreIntegrazione(),null,null)));
  3610.                 }
  3611.                 return;
  3612.             }
  3613.             
  3614.             try {
  3615.                 if(openspcoopstate.resourceReleased()) {
  3616.                     // inizializzo
  3617.                     openspcoopstate.setUseConnection(true);
  3618.                     openspcoopstate.initResource(identitaPdD, this.msgContext.getIdModulo(), idTransazione);
  3619.                 }
  3620.             }catch (Exception e) {
  3621.                 msgDiag.logErroreGenerico(e,"openspcoopstate.initResource() 'invocazionePerRiferimento'");
  3622.                 openspcoopstate.releaseResource();
  3623.                 if (this.msgContext.isGestioneRisposta()) {
  3624.                     this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.GOVWAY_RESOURCES_NOT_AVAILABLE, 
  3625.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  3626.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_505_GET_DB_CONNECTION), e,null)));
  3627.                 }
  3628.                 return;
  3629.             }
  3630.             
  3631.             // eventuale sbustamento delle informazioni di protocollo se richieste dal servizio applicativo
  3632.             GestoreMessaggi gestoreMessaggio = new GestoreMessaggi(openspcoopstate, true,this.msgContext.getIdInvocazionePDPerRiferimento(),Costanti.INBOX,msgDiag,this.msgContext.getPddContext());
  3633.             try{
  3634.                 boolean sbustamento_informazioni_protocollo =
  3635.                         gestoreMessaggio.sbustamentoInformazioniProtocollo(servizioApplicativo,false);
  3636.                 if(sbustamento_informazioni_protocollo){
  3637.                     // attachments non gestiti!
  3638.                     ProprietaManifestAttachments proprietaManifest = propertiesReader.getProprietaManifestAttachments("standard");
  3639.                     proprietaManifest.setGestioneManifest(false);
  3640.                     ProtocolMessage protocolMessage = bustaBuilder.sbustamento(requestMessage, pddContext,
  3641.                             bustaRichiesta, RuoloMessaggio.RICHIESTA, proprietaManifest,
  3642.                             FaseSbustamento.PRE_INVIO_RICHIESTA_PER_RIFERIMENTO, requestInfo.getIntegrationServiceBinding(), requestInfo.getBindingConfig());
  3643.                     if(protocolMessage!=null) {
  3644.                         requestMessage = protocolMessage.getMessage(); // updated
  3645.                     }
  3646.                 }
  3647.             }catch(Exception e){
  3648.                 msgDiag.logErroreGenerico(e,"invocazionePortaDelegataPerRiferimento.sbustamentoProtocolHeader()");
  3649.                 openspcoopstate.releaseResource();
  3650.                 if (this.msgContext.isGestioneRisposta()) {
  3651.                     this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_REQUEST_ERROR,
  3652.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  3653.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE),e,null)));
  3654.                 }
  3655.                 return;     
  3656.             }
  3657.             
  3658.         } else {
  3659.             if (this.msgContext.isInvocazionePDPerRiferimento()) {
  3660.                 msgDiag.logPersonalizzato("portaDelegataInvocabileNormalmente.riferimentoPresente");
  3661.                 openspcoopstate.releaseResource();
  3662.                 if (this.msgContext.isGestioneRisposta()) {
  3663.                     this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.BAD_REQUEST,
  3664.                             ErroriIntegrazione.ERRORE_413_PD_INVOCABILE_SOLO_SENZA_RIFERIMENTO.
  3665.                             getErroreIntegrazione(),null,null)));
  3666.                 }
  3667.                 return;
  3668.             }
  3669.         }

  3671.         
  3672.         
  3673.         
  3674.         
  3675.         
  3676.         
  3677.         
  3678.         
  3679.         
  3680.         
  3681.         
  3682.         
  3683.         
  3684.         
  3685.         
  3686.         
  3687.         
  3688.         Utilities.printFreeMemory("RicezioneContenutiApplicativi - Controllo non esistenza di una busta ...");
  3689.         
  3690.         
  3691.         
  3692.         
  3693.         /* ------------ Controllo che il messaggio non contenga una busta */
  3694.         msgDiag.mediumDebug("Controllo non esistenza di una busta ...");
  3695.         ValidazioneSintattica validatoreSintattico = new ValidazioneSintattica(pddContext, openspcoopstate.getStatoRichiesta(),requestMessage, protocolFactory);
  3696.         boolean esisteProtocolloMsgRichiesta = false;
  3697.         boolean esisteProtocolloMsgRichiestaExit = false;
  3698.         try{
  3699.             esisteProtocolloMsgRichiesta = validatoreSintattico.
  3700.                     verifyProtocolPresence(this.msgContext.getTipoPorta(),infoServizio.getProfiloDiCollaborazione(),RuoloMessaggio.RICHIESTA);
  3701.         } catch (Exception e){
  3702.             msgDiag.logErroreGenerico(e,"controlloEsistenzaBusta");
  3703.             openspcoopstate.releaseResource();
  3704.             if (this.msgContext.isGestioneRisposta()) {
  3705.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_REQUEST_ERROR,
  3706.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  3707.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_525_GESTIONE_FUNZIONALITA_PROTOCOLLO),e,null)));
  3708.             }
  3709.             esisteProtocolloMsgRichiestaExit = true;
  3710.         } finally {
  3711.             if(esisteProtocolloMsgRichiesta) {
  3712.                 msgDiag.logPersonalizzato("richiestaContenenteBusta");
  3713.                 openspcoopstate.releaseResource();
  3714.                 if (this.msgContext.isGestioneRisposta()) {
  3715.                     this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.INTEROPERABILITY_PROFILE_REQUEST_ALREADY_EXISTS,
  3716.                             ErroriIntegrazione.ERRORE_420_BUSTA_PRESENTE_RICHIESTA_APPLICATIVA.
  3717.                             getErroreIntegrazione(),null,null)));
  3718.                 }
  3719.                 esisteProtocolloMsgRichiestaExit = true;
  3720.             }
  3721.             // *** GB ***
  3722.             if(validatoreSintattico!=null){
  3723.                 validatoreSintattico.setHeaderSOAP(null);
  3724.             }
  3725.             validatoreSintattico = null;
  3726.             // *** GB ***
  3727.         }
  3728.         if(esisteProtocolloMsgRichiestaExit) {
  3729.             return;
  3730.         }
  3731.         
  3732.         
  3733.         
  3734.         
  3735.         
  3736.         
  3737.         
  3738.         
  3739.         
  3740.         
  3741.         
  3742.         
  3743.         Utilities.printFreeMemory("RicezioneContenutiApplicativi - Recupero configurazione per salvataggio risposta in cache ...");
  3744.         msgDiag.mediumDebug("Recupero configurazione per salvataggio risposta in cache ...");
  3745.         try{
  3746.             ResponseCachingConfigurazione responseCachingConfig = configurazionePdDReader.getConfigurazioneResponseCaching(portaDelegata);
  3747.             if(responseCachingConfig!=null && StatoFunzionalita.ABILITATO.equals(responseCachingConfig.getStato())) {
  3748.                 
  3749.                 transaction.getTempiElaborazione().startResponseCachingCalcoloDigest();
  3750.                 try {
  3751.                 
  3752.                     msgDiag.mediumDebug("Calcolo digest per salvataggio risposta ...");
  3753.                     
  3754.                     HashGenerator hashGenerator = new HashGenerator(propertiesReader.getCachingResponseDigestAlgorithm());
  3755.                     String digest = hashGenerator.buildKeyCache(requestMessage, requestInfo, responseCachingConfig);
  3756.                     requestMessage.addContextProperty(CostantiPdD.RESPONSE_CACHE_REQUEST_DIGEST, digest);
  3757.                 
  3758.                 }finally {
  3759.                     transaction.getTempiElaborazione().endResponseCachingCalcoloDigest();
  3760.                 }
  3761.             }
  3762.         } catch (Exception e){
  3763.             msgDiag.logErroreGenerico(e,"calcoloDigestSalvataggioRisposta");
  3764.             openspcoopstate.releaseResource();
  3765.             if (this.msgContext.isGestioneRisposta()) {
  3766.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_REQUEST_ERROR,
  3767.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  3768.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_561_DIGEST_REQUEST),e,null)));
  3769.             }
  3770.             return;
  3771.         } 
  3772.         
  3773.         
  3774.         
  3775.         
  3776.         
  3777.         
  3778.         
  3779.         
  3780.         Utilities.printFreeMemory("RicezioneContenutiApplicativi - Update/Delete Header di integrazione se necessario");
  3781.         
  3782.         
  3783.         
  3784.         
  3785.         
  3786.         /*
  3787.          * ------- Update/Delete Header di integrazione se necessario -------
  3788.          */
  3789.         // L'header di integrazione SOAP non e' cancellato se presente.
  3790.         // Deve allora essere aggiornato ai valori letti
  3791.         
  3792.         for (int i = 0; i < tipiIntegrazionePD.length; i++) {
  3793.             try {
  3794.                 IGestoreIntegrazionePD gestore = null;
  3795.                 try {
  3796.                     gestore = (IGestoreIntegrazionePD) pluginLoader.newIntegrazionePortaDelegata(tipiIntegrazionePD[i]);
  3797.                 }catch(Exception e){
  3798.                     throw e;
  3799.                 }
  3800.                 if(gestore!=null){
  3801.                     String classType = null;
  3802.                     try {
  3803.                         classType = gestore.getClass().getName();
  3804.                         AbstractCore.init(gestore, pddContext, protocolFactory);
  3805.                     } catch (Exception e) {
  3806.                         throw new Exception(
  3807.                                 "Riscontrato errore durante l'inizializzazione della classe ["+ classType
  3808.                                         + "] da utilizzare per la gestione dell'integrazione delle fruizioni (Update/Delete) di tipo ["+ tipiIntegrazionePD[i] + "]: " + e.getMessage());
  3809.                     }
  3810.                     if (gestore instanceof IGestoreIntegrazionePDSoap) {
  3811.                         if(propertiesReader.deleteHeaderIntegrazioneRequestPD()){
  3812.                             // delete
  3813.                             ((IGestoreIntegrazionePDSoap)gestore).deleteInRequestHeader(inRequestPDMessage);
  3814.                         }
  3815.                         else{
  3816.                             // update
  3817.                             String servizioApplicativoDaInserireHeader = null;
  3818.                             if(CostantiPdD.SERVIZIO_APPLICATIVO_ANONIMO.equals(servizioApplicativo)==false){
  3819.                                 servizioApplicativoDaInserireHeader = servizioApplicativo;
  3820.                             }
  3821.                             ((IGestoreIntegrazionePDSoap)gestore).updateInRequestHeader(inRequestPDMessage, idServizio, 
  3822.                                     idMessageRequest, servizioApplicativoDaInserireHeader, idCorrelazioneApplicativa);
  3823.                         }
  3824.                     } 
  3825.                 }
  3826.             } catch (Exception e) {
  3827.                 if(propertiesReader.deleteHeaderIntegrazioneRequestPD()){
  3828.                     msgDiag.logErroreGenerico(e,"deleteHeaderIntegrazione("+ tipiIntegrazionePD[i]+")");
  3829.                 }else{
  3830.                     msgDiag.logErroreGenerico(e,"updateHeaderIntegrazione("+ tipiIntegrazionePD[i]+")");
  3831.                 }
  3832.                 openspcoopstate.releaseResource();
  3833.                 if (this.msgContext.isGestioneRisposta()) {
  3834.                     this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_REQUEST_ERROR,
  3835.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  3836.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_541_GESTIONE_HEADER_INTEGRAZIONE),e,null)));
  3837.                 }
  3838.                 return;
  3839.             }
  3840.         }
  3841.         
  3842.         
  3843.         
  3844.         
  3845.         
  3846.         
  3847.         
  3848.         Utilities.printFreeMemory("RicezioneContenutiApplicativi - Gestione Funzionalita' speciali per Attachments (Manifest)");
  3849.         
  3850.         
  3851.         
  3852.         
  3853.         
  3854.         /*
  3855.          * ------------ Gestione Funzionalita' speciali per Attachments (Manifest) -------------
  3856.          */
  3857.         boolean allegaBody = false;
  3858.         boolean scartaBody = false;
  3859.         try {
  3860.             allegaBody = configurazionePdDReader.isAllegaBody(portaDelegata);
  3861.             scartaBody = configurazionePdDReader.isScartaBody(portaDelegata);
  3862.         } catch (Exception e) {
  3863.             msgDiag.logErroreGenerico(e,"configurazionePdDReader.isAllega/ScartaBody(pd)");
  3864.             openspcoopstate.releaseResource();
  3865.             if (this.msgContext.isGestioneRisposta()) {
  3866.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_REQUEST_ERROR,
  3867.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  3868.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE),e,null)));
  3869.             }
  3870.             return;
  3871.         }
  3872.         if (scartaBody) {
  3873.             IntegrationFunctionError integrationFunctionError = null;
  3874.             try {
  3875.                 if(ServiceBinding.SOAP.equals(requestMessage.getServiceBinding())==false){
  3876.                     integrationFunctionError = IntegrationFunctionError.NOT_SUPPORTED_BY_PROTOCOL;
  3877.                     throw new Exception("Funzionalita 'ScartaBody' valida solamente per Service Binding SOAP");
  3878.                 }
  3879.                 
  3880.                 // E' permesso SOLO per messaggi con attachment
  3881.                 if (requestMessage.castAsSoap().countAttachments() <= 0) {
  3882.                     throw new Exception("La funzionalita' e' permessa solo per messaggi SOAP With Attachments");
  3883.                 }
  3884.             } catch (Exception e) {
  3885.                 msgDiag.addKeywordErroreProcessamento(e);
  3886.                 msgDiag.logPersonalizzato("funzionalitaScartaBodyNonEffettuabile");
  3887.                 openspcoopstate.releaseResource();
  3888.                 if (this.msgContext.isGestioneRisposta()) {
  3889.                     if(integrationFunctionError==null) {
  3890.                         integrationFunctionError = IntegrationFunctionError.BAD_REQUEST;
  3891.                     }
  3892.                     this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,integrationFunctionError,
  3893.                             ErroriIntegrazione.ERRORE_425_SCARTA_BODY.
  3894.                             getErrore425_ScartaBody(e.getMessage()),e,null)));
  3895.                 }
  3896.                 return;
  3897.             }
  3898.         }
  3899.         if (allegaBody) {
  3900.             try {
  3901.                 TunnelSoapUtils.allegaBody(requestMessage, propertiesReader.getHeaderSoapActorIntegrazione());
  3902.             } catch (Exception e) {
  3903.                 msgDiag.addKeywordErroreProcessamento(e);
  3904.                 msgDiag.logPersonalizzato("funzionalitaAllegaBodyNonEffettuabile");
  3905.                 openspcoopstate.releaseResource();
  3906.                 if (this.msgContext.isGestioneRisposta()) {
  3907.                     this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.BAD_REQUEST,
  3908.                             ErroriIntegrazione.ERRORE_424_ALLEGA_BODY.
  3909.                             getErrore424_AllegaBody(e.getMessage()), e,null)));
  3910.                 }
  3911.                 return;
  3912.             }
  3913.         }

  3915.         
  3916.         
  3917.         
  3918.         
  3919.         
  3920.         
  3921.         
  3922.         
  3923.         
  3924.         
  3925.         /* ------------- Modalita' di gestione ---------------------------- */
  3926.         
  3927.         // Versione OneWay 
  3928.         boolean oneWayStateless = false;
  3929.         boolean oneWayVersione11 = false;
  3930.         // Versione Sincrono 
  3931.         boolean sincronoStateless = false;
  3932.         // Asincrono stateless
  3933.         boolean asincronoStateless = false;
  3934.         
  3935.         // Gestione stateless
  3936.         boolean portaStateless = false; // vero se almeno uno dei precedenti e' vero

  3938.         try {

  3940.             if(propertiesReader.isServerJ2EE()==false){
  3941.                 // Stateless obbligatorio in server di tipo web (non j2ee)
  3942.                 oneWayStateless = true;
  3943.                 sincronoStateless = true;
  3944.                 asincronoStateless = true;
  3945.             }
  3946.             else if (ProfiloDiCollaborazione.ONEWAY.equals(infoServizio.getProfiloDiCollaborazione())) {
  3947.                 oneWayStateless = configurazionePdDReader.isModalitaStateless(portaDelegata, infoServizio.getProfiloDiCollaborazione());
  3948.             } else if (ProfiloDiCollaborazione.SINCRONO.equals(infoServizio.getProfiloDiCollaborazione())) {
  3949.                 sincronoStateless = configurazionePdDReader.isModalitaStateless(portaDelegata, infoServizio.getProfiloDiCollaborazione());
  3950.             } else if(ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(infoServizio.getProfiloDiCollaborazione()) ||
  3951.                     ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(infoServizio.getProfiloDiCollaborazione())){
  3952.                 asincronoStateless = configurazionePdDReader.isModalitaStateless(portaDelegata, infoServizio.getProfiloDiCollaborazione());
  3953.             }

  3955.             oneWayVersione11 = propertiesReader.isGestioneOnewayStateful_1_1()
  3956.                 && ProfiloDiCollaborazione.ONEWAY.equals(infoServizio.getProfiloDiCollaborazione())
  3957.                     && !oneWayStateless;

  3959.             if (oneWayStateless || sincronoStateless || asincronoStateless || oneWayVersione11) {
  3960.                 openspcoopstate = OpenSPCoopState.toStateless(((OpenSPCoopStateful)openspcoopstate), openspcoopstate.isUseConnection());
  3961.                 portaStateless = true;
  3962.                 if(oneWayVersione11==false){
  3963.                     this.msgContext.getIntegrazione().setGestioneStateless(true);
  3964.                 }else{
  3965.                     this.msgContext.getIntegrazione().setGestioneStateless(false);
  3966.                 }
  3967.             }else{
  3968.                 this.msgContext.getIntegrazione().setGestioneStateless(false);
  3969.             }
  3970.             
  3971.             if(!portaStateless || oneWayVersione11) {
  3972.                 if(!openspcoopstate.isUseConnection() && 
  3973.                         (openspcoopstate instanceof OpenSPCoopStateful || oneWayVersione11)) {
  3974.                     if(openspcoopstate.resourceReleased()) {
  3975.                         // inizializzo
  3976.                         openspcoopstate.setUseConnection(true);
  3977.                         openspcoopstate.initResource(identitaPdD, this.msgContext.getIdModulo(), idTransazione);
  3978.                     }
  3979.                 }
  3980.             }

  3982.         } catch (Exception e) {
  3983.             msgDiag.logErroreGenerico(e,"GestioneStatelessStateful");
  3984.             logError(logCore, "Analisi modalita di gestione STATEFUL/STATELESS non riuscita: "+ e);
  3985.             openspcoopstate.releaseResource();
  3986.             if (this.msgContext.isGestioneRisposta()) {
  3987.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_REQUEST_ERROR,
  3988.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  3989.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_536_CONFIGURAZIONE_NON_DISPONIBILE),e,null)));
  3990.             }
  3991.             return;
  3992.         }

  3994.         
  3995.         
  3996.         
  3997.         
  3998.         

  4000.         
  4001.         
  4002.         
  4003.         /* ------------- Modalita' di forward ---------------------------- */
  4004.         
  4005.         // Versione OneWay 
  4006.         boolean localForward = false;
  4007.         LocalForwardEngine localForwardEngine = null;
  4008.         LocalForwardParameter localForwardParameter = null;
  4009.         PortaApplicativa pa = null;
  4010.         try {

  4012.             localForward = configurazionePdDReader.isLocalForwardMode(portaDelegata);
  4013.             
  4014.             if(localForward){
  4015.                                 
  4016.                 String erroreConfigurazione = null;
  4017.                 
  4018.                 String prefix = "( Servizio "+IDServizioFactory.getInstance().getUriFromIDServizio(idServizio)+" ) ";
  4019.                 
  4020.                 if(ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(infoServizio.getProfiloDiCollaborazione()) ||
  4021.                         ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(infoServizio.getProfiloDiCollaborazione())){
  4022.                     erroreConfigurazione = "profilo di collaborazione "+infoServizio.getProfiloDiCollaborazione().getEngineValue()+" non supportato";                           
  4023.                 }
  4024.                 
  4025.                 if(erroreConfigurazione==null){
  4026.                     if (ProfiloDiCollaborazione.SINCRONO.equals(infoServizio.getProfiloDiCollaborazione())) {
  4027.                         if(sincronoStateless==false){
  4028.                             erroreConfigurazione = "profilo di collaborazione "+infoServizio.getProfiloDiCollaborazione().getEngineValue()+" non supportato nella modalitร  stateful";   
  4029.                         }
  4030.                     }
  4031.                 }
  4032.                 
  4033.                 if(erroreConfigurazione==null){
  4034.                     if(configurazionePdDReader.existsSoggetto(idServizio.getSoggettoErogatore(), requestInfo)==false){
  4035.                         erroreConfigurazione = "il soggetto erogatore non risulta essere gestito localmente dalla Porta";
  4036.                     }
  4037.                 }
  4038.                 
  4039.                 RichiestaApplicativa ra = null;
  4040.                 IDPortaApplicativa idPA = null;
  4041.                 if(erroreConfigurazione==null){

  4043.                     String nomePA = configurazionePdDReader.getLocalForwardNomePortaApplicativa(portaDelegata);
  4044.                     if(nomePA==null){
  4045.                         try{
  4046.                             List<PortaApplicativa> list = configurazionePdDReader.getPorteApplicative(idServizio, false);
  4047.                             if(list.size()<=0){
  4048.                                 throw new DriverConfigurazioneNotFound("NotFound");
  4049.                             }
  4050.                             if(list.size()>1){
  4051.                                 StringBuilder bf = new StringBuilder();
  4052.                                 for (PortaApplicativa portaApplicativa : list) {
  4053.                                     if(bf.length()>0) {
  4054.                                         bf.append(",");
  4055.                                     }
  4056.                                     bf.append(portaApplicativa.getNome());
  4057.                                 }
  4058.                                 throw new Exception("Esiste piรน di una porta applicativa indirizzabile tramite il servizio ["+idServizio+"] indicato nella porta delegata ["+
  4059.                                         nomeUtilizzatoPerErrore+"]: "+bf.toString());
  4060.                             }
  4061.                             idPA = configurazionePdDReader.convertToIDPortaApplicativa(list.get(0));
  4062.                         }catch(DriverConfigurazioneNotFound n){
  4063.                             erroreConfigurazione = "Non esiste alcuna porta applicativa indirizzabile tramite il servizio ["+idServizio+"] indicato nella porta delegata ["+
  4064.                                     nomeUtilizzatoPerErrore+"]";
  4065.                         }catch(Exception e){
  4066.                             erroreConfigurazione = e.getMessage();
  4067.                         }
  4068.                     }
  4069.                     else{
  4070.                         try{
  4071.                             idPA = configurazionePdDReader.getIDPortaApplicativa(nomePA, requestInfo, protocolFactory);
  4072.                         }catch(Exception e){
  4073.                             erroreConfigurazione = e.getMessage();
  4074.                         }
  4075.                     }
  4076.                 }
  4077.                 
  4078.                 if(erroreConfigurazione==null){
  4079.                     ra = new RichiestaApplicativa(soggettoFruitore,idServizio.getSoggettoErogatore(), idPA);
  4080.                     ra.setIntegrazione(this.msgContext.getIntegrazione());
  4081.                     ra.setProtocol(this.msgContext.getProtocol());
  4082.                     pa = configurazionePdDReader.getPortaApplicativaSafeMethod(ra.getIdPortaApplicativa(), requestInfo);
  4083.                     if(pa.sizeServizioApplicativoList()<=0){
  4084.                         erroreConfigurazione = "non risultano registrati servizi applicativi erogatori associati alla porta applicativa ("+pa.getNome()
  4085.                                 +") relativa al servizio richiesto";
  4086.                     }
  4087.                 }
  4088.                 
  4089.                 
  4090.                 if(erroreConfigurazione!=null){
  4091.                     erroreConfigurazione = prefix + erroreConfigurazione;
  4092.                     msgDiag.addKeyword(CostantiPdD.KEY_ERRORE_PROCESSAMENTO,erroreConfigurazione);
  4093.                     msgDiag.logPersonalizzato("localForward.configError");
  4094.                     
  4095.                     openspcoopstate.releaseResource();
  4096.                     if (this.msgContext.isGestioneRisposta()) {
  4097.                         this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_REQUEST_ERROR,
  4098.                                 ErroriIntegrazione.ERRORE_435_LOCAL_FORWARD_CONFIG_NON_VALIDA.
  4099.                                 getErrore435_LocalForwardConfigNonValida(erroreConfigurazione),null,null)));
  4100.                     }
  4101.                     return;
  4102.                 }
  4103.                 
  4104.                 localForwardParameter = new LocalForwardParameter();
  4105.                 localForwardParameter.setLog(logCore);
  4106.                 localForwardParameter.setConfigurazionePdDReader(configurazionePdDReader);
  4107.                 localForwardParameter.setIdCorrelazioneApplicativa(idCorrelazioneApplicativa);
  4108.                 localForwardParameter.setIdentitaPdD(identitaPdD);
  4109.                 localForwardParameter.setIdModulo(this.msgContext.getIdModulo());
  4110.                 localForwardParameter.setIdRequest(idMessageRequest);
  4111.                 localForwardParameter.setImplementazionePdDDestinatario(implementazionePdDDestinatario);
  4112.                 localForwardParameter.setImplementazionePdDMittente(implementazionePdDMittente);
  4113.                 localForwardParameter.setIdPdDMittente(idPdDMittente);
  4114.                 localForwardParameter.setIdPdDDestinatario(idPdDDestinatario);
  4115.                 localForwardParameter.setInfoServizio(infoServizio);
  4116.                 localForwardParameter.setMsgDiag(msgDiag);
  4117.                 localForwardParameter.setOpenspcoopstate(openspcoopstate);
  4118.                 localForwardParameter.setPddContext(inRequestContext.getPddContext());
  4119.                 localForwardParameter.setProtocolFactory(protocolFactory);
  4120.                 localForwardParameter.setRichiestaDelegata(richiestaDelegata);
  4121.                 localForwardParameter.setStateless(portaStateless);
  4122.                 localForwardParameter.setOneWayVersione11(oneWayVersione11);
  4123.                 localForwardParameter.setIdPortaApplicativaIndirizzata(idPA);
  4124.                 
  4125.                 localForwardEngine = new LocalForwardEngine(localForwardParameter);
  4126.                             
  4127.             }
  4128.             
  4129.         } catch (Exception e) {
  4130.             msgDiag.logErroreGenerico(e,"GestioneLocalForward");
  4131.             openspcoopstate.releaseResource();
  4132.             if (this.msgContext.isGestioneRisposta()) {
  4133.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_REQUEST_ERROR,
  4134.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  4135.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_554_LOCAL_FORWARD_ERROR),e,null)));
  4136.             }
  4137.             return;
  4138.         }
  4139.         
  4140.         
  4141.         if(localForward){
  4142.             try {
  4143.                 if(localForwardEngine.processRequest(requestMessage)==false){
  4144.                     openspcoopstate.releaseResource();
  4145.                     if (this.msgContext.isGestioneRisposta()) {
  4146.                         this.msgContext.setMessageResponse(localForwardEngine.getResponseMessageError());
  4147.                     }
  4148.                     return;
  4149.                 }
  4150.                 if(localForwardEngine.getRequestMessageAfterProcess()!=null){
  4151.                     // Messaggio aggiornato
  4152.                     requestMessage = localForwardEngine.getRequestMessageAfterProcess();
  4153.                 }
  4154.             } catch (Exception e) {
  4155.                 msgDiag.logErroreGenerico(e,"GestioneLocalForward.processRequest");
  4156.                 openspcoopstate.releaseResource();
  4157.                 if (this.msgContext.isGestioneRisposta()) {
  4158.                     this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,AbstractErrorGenerator.getIntegrationInternalError(pddContext),
  4159.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  4160.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_555_LOCAL_FORWARD_PROCESS_REQUEST_ERROR),e,null)));
  4161.                 }
  4162.                 return;
  4163.             }
  4164.         }
  4165.         
  4166.         
  4167.         
  4168.         
  4169.         
  4170.         
  4171.         
  4172.         
  4173.         
  4174.         
  4175.         
  4176.         
  4177.         
  4178.         
  4179.         
  4180.         
  4181.         Utilities.printFreeMemory("RicezioneContenutiApplicativi - Controllo presenza del messaggio gia' in gestione...");
  4182.         
  4183.         
  4184.         
  4185.         
  4186.         
  4187.         /* ---------------- Controllo esistenza messaggio --------------------- */
  4188.         msgDiag.mediumDebug("Controllo presenza del messaggio gia' in gestione...");
  4189.         GestoreMessaggi msgRequest = null;
  4190.         String tipoMessaggio = Costanti.OUTBOX;
  4191.         if(localForward){
  4192.             tipoMessaggio = Costanti.INBOX;
  4193.         }
  4194.         msgRequest = new GestoreMessaggi(openspcoopstate, true,idMessageRequest, tipoMessaggio, msgDiag, inRequestContext.getPddContext());
  4195.         msgRequest.setOneWayVersione11(oneWayVersione11);
  4196.         RepositoryBuste repositoryBuste = new RepositoryBuste(openspcoopstate.getStatoRichiesta(), true, protocolFactory);
  4197.         try {
  4198.             if (msgRequest.existsMessage_noCache()) {

  4200.                 // Se il proprietario attuale e' GestoreMessaggi, forzo
  4201.                 // l'eliminazione e continuo a processare il messaggio.
  4202.                 String proprietarioMessaggio = msgRequest.getProprietario(this.msgContext.getIdModulo());
  4203.                 if (TimerGestoreMessaggi.ID_MODULO.equals(proprietarioMessaggio)) {
  4204.                     msgDiag.logPersonalizzato("messaggioInGestione.marcatoDaEliminare");
  4205.                     String msg = msgDiag.getMessaggio_replaceKeywords("messaggioInGestione.marcatoDaEliminare");
  4206.                     if(propertiesReader.isMsgGiaInProcessamentoUseLock()) {
  4207.                         msgRequest._deleteMessageWithLock(msg,propertiesReader.getMsgGiaInProcessamentoAttesaAttiva(),propertiesReader.getMsgGiaInProcessamentoCheckInterval());
  4208.                     }
  4209.                     else {
  4210.                         msgRequest.deleteMessageByNow();
  4211.                     }
  4212.                 }

  4214.                 // Altrimenti genero errore messaggio precedente ancora in
  4215.                 // processamento
  4216.                 else {
  4217.                     msgDiag.addKeyword(CostantiPdD.KEY_PROPRIETARIO_MESSAGGIO, proprietarioMessaggio);
  4218.                     msgDiag.logPersonalizzato("messaggioInGestione");
  4219.                     pddContext.addObject(org.openspcoop2.core.constants.Costanti.RICHIESTA_DUPLICATA, "true");
  4220.                     openspcoopstate.releaseResource(); 
  4221.                     if (this.msgContext.isGestioneRisposta()) {
  4222.                         this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.CONFLICT_IN_QUEUE,
  4223.                                 ErroriIntegrazione.ERRORE_537_BUSTA_GIA_RICEVUTA.get537_BustaGiaRicevuta(idMessageRequest),null,null)));
  4224.                     }
  4225.                     return;
  4226.                 }
  4227.             }
  4228.         } catch (Exception e) {
  4229.             msgDiag.logErroreGenerico(e,"ControlloPresenzaMessaggioGiaInGestione");
  4230.             logError(logCore, "Controllo/gestione presenza messaggio gia in gestione non riuscito",e);
  4231.             openspcoopstate.releaseResource();
  4232.             if (this.msgContext.isGestioneRisposta()) {
  4233.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,AbstractErrorGenerator.getIntegrationInternalError(pddContext),
  4234.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  4235.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_537_BUSTA_GIA_RICEVUTA), e,null)));
  4236.             }
  4237.             return;
  4238.         }
  4239.         
  4240.         
  4241.         
  4242.         
  4243.         
  4244.         
  4245.         
  4246.         
  4247.         
  4248.         Utilities.printFreeMemory("RicezioneContenutiApplicativi - Registrazione messaggio di richiesta nel RepositoryMessaggi...");
  4249.         
  4250.         
  4251.         
  4252.         
  4253.         
  4254.         /*
  4255.          * ---------------- Creo sessione di gestione del messaggio ricevuto Il
  4256.          * messaggio viene assegnato al modulo 'Imbustamento' (futuro
  4257.          * proprietario) ---------------------
  4258.          */
  4259.         msgDiag.mediumDebug("Registrazione messaggio di richiesta nel RepositoryMessaggi...");
  4260.         IProtocolVersionManager moduleManager = protocolFactory.createProtocolVersionManager(richiestaDelegata.getProfiloGestione());
  4261.         boolean richiestaAsincronaSimmetricaStateless = false;      
  4262.         try {
  4263.             
  4264.             // In caso di richiestaAsincronaSimmetrica e openspcoop stateless,
  4265.             // Devo comunque salvare le informazioni sul msg della richiesta.
  4266.             // Tali informazioni servono per il check nel modulo RicezioneBuste, per verificare di gestire la risposta
  4267.             // solo dopo aver terminato di gestire la richiesta con relativa ricevuta.
  4268.             if(ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(infoServizio.getProfiloDiCollaborazione()) && portaStateless){
  4269.                 
  4270.                 if (StatoFunzionalitaProtocollo.ABILITATA.equals(moduleManager.getCollaborazione(infoServizio))) {
  4271.                     // Se presente riferimentoMessaggio utilizzo quello come riferimento asincrono per la risposta.
  4272.                     if (headerIntegrazioneRichiesta.getBusta().getRiferimentoMessaggio() != null) {
  4273.                         richiestaAsincronaSimmetricaStateless = false;
  4274.                     } else if (headerIntegrazioneRichiesta.getBusta().getIdCollaborazione() != null) {
  4275.                         // Utilizzo Collaborazione come riferimentoServizioCorrelato
  4276.                         // Tanto nelle linee guida non possono esistere piu' istanze con la stessa collaborazione, e' stata deprecata.
  4277.                         // Per igni istanza asincrona (richiesta/risposta) la richiesta genera una collaborazione a capostipite
  4278.                         richiestaAsincronaSimmetricaStateless = false;
  4279.                     }else{
  4280.                         richiestaAsincronaSimmetricaStateless = true;
  4281.                     }
  4282.                 } else {
  4283.                     richiestaAsincronaSimmetricaStateless = headerIntegrazioneRichiesta.getBusta().getRiferimentoMessaggio() == null;
  4284.                 }

  4286.             }
  4287.             
  4288.             
  4289.             // Salvataggio messaggio
  4290.             msgRequest.registraMessaggio(requestMessage, dataIngressoRichiesta,
  4291.                     (oneWayStateless || sincronoStateless || asincronoStateless),
  4292.                     idCorrelazioneApplicativa); 
  4293.             if(localForward){
  4294.                 msgRequest.aggiornaProprietarioMessaggio(org.openspcoop2.pdd.mdb.ConsegnaContenutiApplicativi.ID_MODULO);
  4295.             }else{
  4296.                 msgRequest.aggiornaProprietarioMessaggio(org.openspcoop2.pdd.mdb.Imbustamento.ID_MODULO);
  4297.             }
  4298.                         
  4299.             if(richiestaAsincronaSimmetricaStateless){
  4300.                 if(openspcoopstate.resourceReleased()) {
  4301.                     // inizializzo
  4302.                     openspcoopstate.setUseConnection(true);
  4303.                     openspcoopstate.initResource(identitaPdD, this.msgContext.getIdModulo(), idTransazione);
  4304.                 }
  4305.                 msgRequest.registraInformazioniMessaggio_statelessEngine(dataIngressoRichiesta, org.openspcoop2.pdd.mdb.Imbustamento.ID_MODULO,
  4306.                         idCorrelazioneApplicativa);
  4307.             }
  4308.             
  4309.         } catch (Exception e) {
  4310.             msgDiag.logErroreGenerico(e,"msgRequest.aggiornaProprietarioMessaggio");
  4311.             msgRequest.deleteMessageFromFileSystem(); // elimino richiesta salvata su fileSystem
  4312.             // Rilascio Connessione DB
  4313.             openspcoopstate.releaseResource();
  4314.             if (this.msgContext.isGestioneRisposta()) {
  4315.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,AbstractErrorGenerator.getIntegrationInternalError(pddContext),
  4316.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  4317.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_508_SAVE_REQUEST_MSG), e,null)));
  4318.             }
  4319.             return;
  4320.         }

  4322.         msgDiag.mediumDebug("Registrazione busta di richiesta nel RepositoryBuste...");
  4323.         try {
  4324.             if( (!portaStateless) || oneWayVersione11){
  4325.                 // E' gia registrata se siamo in un contesto di correlazione applicativa                
  4326.                 if (repositoryBuste.isRegistrata(idMessageRequest,tipoMessaggio)) {
  4327.                     try{
  4328.                         if(localForward){
  4329.                             repositoryBuste.aggiornaBustaIntoInBox(idMessageRequest, soggettoFruitore, richiestaDelegata.getIdServizio(), 
  4330.                                     propertiesReader.getRepositoryIntervalloScadenzaMessaggi(), 
  4331.                                     infoServizio.getProfiloDiCollaborazione(), infoServizio.getConfermaRicezione(), infoServizio.getInoltro());
  4332.                         }else{
  4333.                             repositoryBuste.aggiornaBustaIntoOutBox(idMessageRequest, soggettoFruitore, richiestaDelegata.getIdServizio(),
  4334.                                     propertiesReader.getRepositoryIntervalloScadenzaMessaggi(),
  4335.                                     infoServizio.getProfiloDiCollaborazione(), infoServizio.getConfermaRicezione(), infoServizio.getInoltro());
  4336.                         }
  4337.                         repositoryBuste.impostaUtilizzoPdD(idMessageRequest,tipoMessaggio);
  4338.                     }catch(Exception e){
  4339.                         if(propertiesReader.isMsgGiaInProcessamentoUseLock()) {
  4340.                             String tipo = Costanti.OUTBOX;
  4341.                             if(localForward){
  4342.                                 tipo = Costanti.INBOX;  
  4343.                             }
  4344.                             String causa = "Aggiornamento dati busta con id ["+idMessageRequest+"] tipo["+tipo+"] non riuscito: "+e.getMessage();
  4345.                             try{
  4346.                                 GestoreMessaggi.acquireLock(msgRequest,TimerLock.newInstance(TipoLock._getLockGestioneRepositoryMessaggi()),msgDiag, causa, propertiesReader.getMsgGiaInProcessamentoAttesaAttiva(), propertiesReader.getMsgGiaInProcessamentoCheckInterval());
  4347.                                 // errore che puo' avvenire a causa del Timer delle Buste (vedi spiegazione in classe GestoreMessaggi.deleteMessageWithLock)
  4348.                                 // Si riesegue tutto il codice isRegistrata e update o create con il lock. Stavolta se avviene un errore non e' dovuto al timer.
  4349.                                 if (repositoryBuste.isRegistrata(idMessageRequest,tipoMessaggio)) {
  4350.                                     if(localForward){
  4351.                                         repositoryBuste.aggiornaBustaIntoInBox(idMessageRequest, soggettoFruitore, richiestaDelegata.getIdServizio(), 
  4352.                                                 propertiesReader.getRepositoryIntervalloScadenzaMessaggi(), 
  4353.                                                 infoServizio.getProfiloDiCollaborazione(), infoServizio.getConfermaRicezione(), infoServizio.getInoltro());
  4354.                                     }else{
  4355.                                         repositoryBuste.aggiornaBustaIntoOutBox(idMessageRequest, soggettoFruitore, richiestaDelegata.getIdServizio(),
  4356.                                                 propertiesReader.getRepositoryIntervalloScadenzaMessaggi(),
  4357.                                                 infoServizio.getProfiloDiCollaborazione(), infoServizio.getConfermaRicezione(), infoServizio.getInoltro());
  4358.                                     }
  4359.                                     repositoryBuste.impostaUtilizzoPdD(idMessageRequest,tipoMessaggio);
  4360.                                 }
  4361.                                 else {
  4362.                                     if(localForward){
  4363.                                         repositoryBuste.registraBustaIntoInBox(idMessageRequest, soggettoFruitore, richiestaDelegata.getIdServizio(),
  4364.                                                 propertiesReader.getRepositoryIntervalloScadenzaMessaggi(),
  4365.                                                 infoServizio.getProfiloDiCollaborazione(), infoServizio.getConfermaRicezione(), infoServizio.getInoltro());
  4366.                                     }
  4367.                                     else{
  4368.                                         repositoryBuste.registraBustaIntoOutBox(idMessageRequest,soggettoFruitore, richiestaDelegata.getIdServizio(),
  4369.                                                 propertiesReader.getRepositoryIntervalloScadenzaMessaggi(),
  4370.                                                 infoServizio.getProfiloDiCollaborazione(), infoServizio.getConfermaRicezione(), infoServizio.getInoltro());
  4371.                                     }
  4372.                                 }
  4373.                             }finally{
  4374.                                 try{
  4375.                                     GestoreMessaggi.releaseLock(msgRequest,TimerLock.newInstance(TipoLock._getLockGestioneRepositoryMessaggi()),msgDiag, causa);
  4376.                                 }catch(Exception eUnlock){
  4377.                                     // ignore
  4378.                                 }
  4379.                             }
  4380.                         }
  4381.                         else {
  4382.                             throw e;
  4383.                         }
  4384.                     }
  4385.                 } else {
  4386.                     if(localForward){
  4387.                         repositoryBuste.registraBustaIntoInBox(idMessageRequest, soggettoFruitore, richiestaDelegata.getIdServizio(),
  4388.                                 propertiesReader.getRepositoryIntervalloScadenzaMessaggi(),
  4389.                                 infoServizio.getProfiloDiCollaborazione(), infoServizio.getConfermaRicezione(), infoServizio.getInoltro());
  4390.                     }
  4391.                     else{
  4392.                         repositoryBuste.registraBustaIntoOutBox(idMessageRequest,soggettoFruitore, richiestaDelegata.getIdServizio(),
  4393.                                 propertiesReader.getRepositoryIntervalloScadenzaMessaggi(),
  4394.                                 infoServizio.getProfiloDiCollaborazione(), infoServizio.getConfermaRicezione(), infoServizio.getInoltro());
  4395.                     }
  4396.                 }
  4397.                 Integrazione infoIntegrazione = new Integrazione();
  4398.                 infoIntegrazione.setIdModuloInAttesa(this.msgContext.getIdModulo());
  4399.                 infoIntegrazione.setNomePorta(richiestaDelegata.getIdPortaDelegata().getNome());
  4400.                 infoIntegrazione.setServizioApplicativo(richiestaDelegata.getServizioApplicativo());
  4401.                 repositoryBuste.aggiornaInfoIntegrazione(idMessageRequest,tipoMessaggio,infoIntegrazione);
  4402.             }
  4403.         } catch (Exception e) {
  4404.             msgDiag.logErroreGenerico(e,"registrazioneAggiornamentoBusta");
  4405.             msgRequest.deleteMessageFromFileSystem(); // elimino richiesta salvata su fileSystem
  4406.             openspcoopstate.releaseResource();
  4407.             if (this.msgContext.isGestioneRisposta()) {
  4408.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,AbstractErrorGenerator.getIntegrationInternalError(pddContext),
  4409.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  4410.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_525_GESTIONE_FUNZIONALITA_PROTOCOLLO), e,null)));
  4411.             }
  4412.             return;
  4413.         }

  4415.         
  4416.         
  4417.         
  4418.         
  4419.         
  4420.         Utilities.printFreeMemory("RicezioneContenutiApplicativi - Invio messaggio al modulo di Imbustamento...");
  4421.         
  4422.         
  4423.         
  4424.         
  4425.         
  4426.         
  4427.         /* ------------ Spedizione a modulo Imbustamento/ConsegnaContenutiApplicativi ------------- */
  4428.         String nextModulo = org.openspcoop2.pdd.mdb.Imbustamento.ID_MODULO;
  4429.         if(localForward){
  4430.             msgDiag.addKeyword(CostantiPdD.KEY_PORTA_APPLICATIVA,pa.getNome());
  4431.             if(idServizio.getAzione()==null){
  4432.                 msgDiag.addKeyword(CostantiPdD.KEY_AZIONE_BUSTA_RICHIESTA,"non presente");
  4433.             }
  4434.             msgDiag.logPersonalizzato("localForward.logInfo");
  4435.             nextModulo = ConsegnaContenutiApplicativi.ID_MODULO;
  4436.         }else{
  4437.             msgDiag.mediumDebug("Invio messaggio al modulo di Imbustamento...");
  4438.         }
  4439.         try {
  4440.             
  4441.             // set tipologia di filtro duplicati
  4442.             if(proprietaPorta!=null && !proprietaPorta.isEmpty()) {
  4443.                 boolean filtroDuplicatiTestEnabled = CostantiProprieta.isFiltroDuplicatiTestEnabled(proprietaPorta, false); // filtro duplicati usato per test
  4444.                 if(filtroDuplicatiTestEnabled) {
  4445.                     pddContext.addObject(CostantiPdD.FILTRO_DUPLICATI_TEST, filtroDuplicatiTestEnabled);
  4446.                 }
  4447.             }
  4448.             
  4449.             // Creazione ImbustamentoMessage
  4450.             msgDiag.highDebug("Creazione ObjectMessage for send nell'infrastruttura.");

  4452.             Serializable msgJMS = null;
  4453.             
  4454.             if(localForward){
  4455.             
  4456.                 localForwardParameter.setRepositoryBuste(repositoryBuste);
  4457.                 String portaDelegataAttuale = localForwardParameter.getMsgDiag().getPorta();
  4458.                 localForwardParameter.getMsgDiag().updatePorta(TipoPdD.APPLICATIVA,localForwardParameter.getIdPortaApplicativaIndirizzata().getNome(), requestInfo);
  4459.                 localForwardEngine.updateLocalForwardParameter(localForwardParameter);
  4460.                 
  4461.                 localForwardEngine.sendRequest(msgRequest);
  4462.                 
  4463.                 // ripristino
  4464.                 localForwardParameter.getMsgDiag().updatePorta(TipoPdD.DELEGATA,portaDelegataAttuale, requestInfo);
  4465.                 
  4466.             }
  4467.             else{
  4468.                 imbustamentoMSG.setRichiestaDelegata(richiestaDelegata);
  4469.                 imbustamentoMSG.setInfoServizio(infoServizio);
  4470.                 imbustamentoMSG.setOneWayVersione11(oneWayVersione11);
  4471.                 if (headerIntegrazioneRichiesta.getBusta() != null) {
  4472.                     // RiferimentoServizioCorrelato
  4473.                     String riferimentoServizioCorrelato = moduleManager.getIdCorrelazioneAsincrona(
  4474.                             headerIntegrazioneRichiesta.getBusta().getRiferimentoMessaggio(), headerIntegrazioneRichiesta.getBusta().getIdCollaborazione());
  4475.                     if (riferimentoServizioCorrelato != null) {
  4476.                         // Se presente riferimentoMessaggio utilizzo quello.
  4477.                         imbustamentoMSG.setRiferimentoServizioCorrelato(riferimentoServizioCorrelato);
  4478.                     }
  4479.                     // Collaborazione
  4480.                     if (headerIntegrazioneRichiesta.getBusta().getIdCollaborazione() != null)
  4481.                         imbustamentoMSG.setIdCollaborazione(headerIntegrazioneRichiesta.getBusta().getIdCollaborazione());
  4482.                     // RiferimentoMessaggio
  4483.                     if (headerIntegrazioneRichiesta.getBusta().getRiferimentoMessaggio() != null)
  4484.                         imbustamentoMSG.setIdRiferimentoMessaggio(headerIntegrazioneRichiesta.getBusta().getRiferimentoMessaggio());
  4485.                 }
  4486.                 // Implemnentazione della porta erogatrice
  4487.                 imbustamentoMSG.setImplementazionePdDSoggettoMittente(implementazionePdDMittente);
  4488.                 imbustamentoMSG.setImplementazionePdDSoggettoDestinatario(implementazionePdDDestinatario);
  4489.                 // Indirizzo soggetti
  4490.                 imbustamentoMSG.setIndirizzoSoggettoMittente(indirizzoFruitore);
  4491.                 imbustamentoMSG.setIndirizzoSoggettoDestinatario(indirizzoErogatore);
  4492.                 // PddContext
  4493.                 imbustamentoMSG.setPddContext(inRequestContext.getPddContext());
  4494.             
  4495.                 msgJMS = imbustamentoMSG;
  4496.             }

  4498.             if (!portaStateless) {
  4499.                 logDebug(logCore, RicezioneContenutiApplicativi.ID_MODULO+ " :eseguo send verso "+nextModulo+"...");
  4500.                 
  4501.                 String classTypeNodeSender = null;
  4502.                 INodeSender nodeSender = null;
  4503.                 try {
  4504.                     classTypeNodeSender = className.getNodeSender(propertiesReader.getNodeSender());
  4505.                     nodeSender = (INodeSender) loader.newInstance(classTypeNodeSender);
  4506.                 } catch (Exception e) {
  4507.                     throw new Exception(
  4508.                             "Riscontrato errore durante il caricamento della classe ["+ classTypeNodeSender
  4509.                                     + "] da utilizzare per la spedizione nell'infrastruttura: " + e.getMessage());
  4510.                 }
  4511.                 
  4512.                 // send JMS solo STATEFUL
  4513.                 nodeSender.send(msgJMS,nextModulo, msgDiag,
  4514.                         identitaPdD, this.msgContext.getIdModulo(), idMessageRequest, msgRequest);
  4515.                 logDebug(logCore, RicezioneContenutiApplicativi.ID_MODULO+ " :send verso "+nextModulo+" effettuata");
  4516.             }

  4518.         } catch (Exception e) {
  4519.             logError(logCore, "Spedizione->"+nextModulo+" non riuscita",e);
  4520.             msgDiag.logErroreGenerico(e,"GenericLib.nodeSender.send("+nextModulo+")");
  4521.             msgRequest.deleteMessageFromFileSystem(); // elimino richiesta salvata precedentemente
  4522.             openspcoopstate.releaseResource();
  4523.             if (this.msgContext.isGestioneRisposta()) {
  4524.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,AbstractErrorGenerator.getIntegrationInternalError(pddContext),
  4525.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  4526.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_512_SEND),e,null)));
  4527.             }
  4528.             return;
  4529.         }

  4531.         
  4532.         
  4533.         
  4534.         
  4535.         Utilities.printFreeMemory("RicezioneContenutiApplicativi - Commit delle operazioni per la gestione della richiesta...");
  4536.         
  4537.         
  4538.         
  4539.         
  4540.         /* ------------ Commit/Rilascia connessione al DB ------------- */
  4541.         msgDiag.mediumDebug("Commit delle operazioni per la gestione della richiesta...");
  4542.         try {
  4543.             // Commit
  4544.             openspcoopstate.commit();
  4545.             logDebug(logCore, RicezioneContenutiApplicativi.ID_MODULO+ " :RicezioneContenutiApplicativi commit eseguito");
  4546.         } catch (Exception e) {
  4547.             msgDiag.logErroreGenerico(e,"openspcoopstate.commit");
  4548.             msgRequest.deleteMessageFromFileSystem(); // elimino richiesta salvata precedentemente
  4549.             openspcoopstate.releaseResource();
  4550.             if (this.msgContext.isGestioneRisposta()) {
  4551.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,AbstractErrorGenerator.getIntegrationInternalError(pddContext),
  4552.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  4553.                         get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_506_COMMIT_JDBC),e,null)));
  4554.             }
  4555.             return;
  4556.         }

  4558.         if (!portaStateless) {
  4559.             // Aggiornamento cache messaggio
  4560.             if (msgRequest != null)
  4561.                 msgRequest.addMessaggiIntoCache_readFromTable(RicezioneContenutiApplicativi.ID_MODULO, "richiesta");
  4562.             // Aggiornamento cache proprietario messaggio
  4563.             if (msgRequest != null)
  4564.                 msgRequest.addProprietariIntoCache_readFromTable(RicezioneContenutiApplicativi.ID_MODULO, "richiesta",null, false);

  4566.             // Rilascia connessione al DB
  4567.             msgDiag.mediumDebug("Commit delle operazioni per la gestione della richiesta effettuato, rilascio della connessione...");
  4568.             openspcoopstate.releaseResource();
  4569.         }

  4571.         
  4572.         
  4573.         
  4574.         
  4575.     
  4576.         
  4577.         
  4578.         
  4579.         /* ---------- Parametri Gestione risposta ------------- */
  4580.         RicezioneContenutiApplicativiGestioneRisposta parametriGestioneRisposta =
  4581.             new RicezioneContenutiApplicativiGestioneRisposta();

  4583.         parametriGestioneRisposta.setOpenspcoopstate(openspcoopstate);
  4584.         
  4585.         parametriGestioneRisposta.setRegistroServiziReader(registroServiziReader);
  4586.         parametriGestioneRisposta.setConfigurazionePdDReader(configurazionePdDReader);
  4587.         parametriGestioneRisposta.setMsgDiag(msgDiag);
  4588.         parametriGestioneRisposta.setLogCore(logCore);
  4589.         parametriGestioneRisposta.setPropertiesReader(propertiesReader);
  4590.         
  4591.         parametriGestioneRisposta.setIdentitaPdD(identitaPdD);
  4592.         parametriGestioneRisposta.setIdMessageRequest(idMessageRequest);
  4593.         
  4594.         parametriGestioneRisposta.setHeaderIntegrazioneRichiesta(headerIntegrazioneRichiesta);
  4595.         parametriGestioneRisposta.setHeaderIntegrazioneRisposta(headerIntegrazioneRisposta);
  4596.         parametriGestioneRisposta.setTipiIntegrazionePD(tipiIntegrazionePD);
  4597.         
  4598.         parametriGestioneRisposta.setProprietaErroreAppl(proprietaErroreAppl);
  4599.         parametriGestioneRisposta.setServizioApplicativo(servizioApplicativo);
  4600.         
  4601.         parametriGestioneRisposta.setMsgRequest(msgRequest);
  4602.         parametriGestioneRisposta.setRepositoryBuste(repositoryBuste);
  4603.         
  4604.         parametriGestioneRisposta.setPortaStateless(portaStateless);
  4605.         parametriGestioneRisposta.setOneWayVers11(oneWayVersione11);
  4606.         parametriGestioneRisposta.setRichiestaAsincronaSimmetricaStateless(richiestaAsincronaSimmetricaStateless);

  4608.         parametriGestioneRisposta.setPortaDelegata(portaDelegata);
  4609.         parametriGestioneRisposta.setSoggettoMittente(soggettoFruitore);
  4610.         parametriGestioneRisposta.setIdServizio(idServizio);
  4611.         
  4612.         parametriGestioneRisposta.setLocalForward(localForward);
  4613.         
  4614.         parametriGestioneRisposta.setPddContext(inRequestContext.getPddContext());
  4615.         parametriGestioneRisposta.setProtocolFactory(protocolFactory);
  4616.         
  4617.         parametriGestioneRisposta.setBustaRichiesta(bustaRichiesta);
  4618.         
  4619.         

  4621.         
  4622.         
  4623.         
  4624.         /*
  4625.          * ---------------- STATELESS OR Stateful v11 -------------
  4626.          */
  4627.         if (portaStateless) {
  4628.             
  4629.             //  Durante le invocazioni non deve essere utilizzata la connessione al database 
  4630.             ((OpenSPCoopStateless)openspcoopstate).setUseConnection(false);
  4631.             boolean result = comportamentoStateless(parametriGestioneRisposta, imbustamentoMSG);
  4632.             if (!result){
  4633.                 openspcoopstate.releaseResource();
  4634.                 return;
  4635.             }else{
  4636.                 // ripristino utilizzo connessione al database
  4637.                 ((OpenSPCoopStateless)openspcoopstate).setUseConnection(true);
  4638.             }
  4639.         }

  4641.         
  4642.         // refresh risorse con nuovi stati
  4643.         registroServiziReader = registroServiziReader.refreshState(openspcoopstate.getStatoRichiesta(),openspcoopstate.getStatoRisposta());
  4644.         configurazionePdDReader = configurazionePdDReader.refreshState(registroServiziReader);
  4645.         msgDiag.updateState(configurazionePdDReader);
  4646.         
  4647.         
  4648.         
  4649.         Utilities.printFreeMemory("RicezioneContenutiApplicativi - Gestione risposta...");
  4650.         
  4651.         
  4652.         /* ------------ GestioneRisposta non effettuata ------------- */
  4653.         msgDiag.mediumDebug("Gestione risposta...");
  4654.         if (this.msgContext.isGestioneRisposta() == false) {
  4655.             if(portaStateless)
  4656.                 openspcoopstate.releaseResource();
  4657.             return;
  4658.         }

  4660.         gestioneRisposta(parametriGestioneRisposta);
  4661.         msgDiag.mediumDebug("Lavoro Terminato.");

  4663.         }finally{ // try vedi  #try-finally-openspcoopstate#
  4664.             try{
  4665.                 if(openspcoopstate!=null){
  4666.                     openspcoopstate.forceFinallyReleaseResource();
  4667.                 }
  4668.             }catch(Throwable e){
  4669.                 if(msgDiag!=null){
  4670.                     try{
  4671.                         msgDiag.logErroreGenerico(e, "Rilascio risorsa");
  4672.                     }catch(Throwable eLog){
  4673.                         logError(logCore, "Diagnostico errore per Rilascio risorsa: "+eLog.getMessage(),eLog);
  4674.                     }
  4675.                 }
  4676.                 else{
  4677.                     logError(logCore, "Rilascio risorsa: "+e.getMessage(),e);
  4678.                 }
  4679.             }
  4680.         }
  4681.     }

  4683.     
  4684.     private void setCredenziali(Credenziali credenziali,MsgDiagnostico msgDiag){
  4685.         if (credenziali != null) {
  4686.             if (credenziali.getUsername() != null){
  4687.                 msgDiag.setServizioApplicativo("username("+ credenziali.getUsername() + ")");
  4688.             }else if (credenziali.getSubject() != null){
  4689.                 msgDiag.setServizioApplicativo("subject("+ credenziali.getSubject() + ")");
  4690.             }else if (credenziali.getPrincipal() != null){
  4691.                 msgDiag.setServizioApplicativo("principal("+ credenziali.getPrincipal() + ")");
  4692.             }
  4693.             else{
  4694.                 msgDiag.setServizioApplicativo(null);
  4695.             }
  4696.         }
  4697.         
  4698.         String credenzialiFornite = "";
  4699.         if(credenziali!=null){
  4700.             credenzialiFornite = credenziali.toString();
  4701.         }
  4702.         msgDiag.addKeyword(CostantiPdD.KEY_CREDENZIALI_SA_FRUITORE, credenzialiFornite);
  4703.     }
  4704.     
  4705.     
  4706.     /*
  4707.      * Gestione stateless
  4708.      */
  4709.     private boolean comportamentoStateless(RicezioneContenutiApplicativiGestioneRisposta parametriGestioneRisposta,
  4710.             ImbustamentoMessage imbustamentoMSG)  {

  4712.         
  4713.         /* ------- Lettura parametri ---------- */
  4714.         
  4715.         EsitoLib esito;
  4716.         
  4717.         OpenSPCoopStateless openspcoopstate = (OpenSPCoopStateless) parametriGestioneRisposta.getOpenspcoopstate();
  4718.         
  4719.         ConfigurazionePdDManager configurazionePdDReader = parametriGestioneRisposta.getConfigurazionePdDReader();
  4720.         RegistroServiziManager registroServiziReader = parametriGestioneRisposta.getRegistroServiziReader();
  4721.         MsgDiagnostico msgDiag = parametriGestioneRisposta.getMsgDiag();
  4722.         Logger logCore = parametriGestioneRisposta.getLogCore();
  4723.         OpenSPCoop2Properties propertiesReader = parametriGestioneRisposta.getPropertiesReader();
  4724.         
  4725.         //SOAPVersion versioneSoap = (SOAPVersion) this.msgContext.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.SOAP_VERSION);
  4726.         
  4727.         String idMessageRequest = parametriGestioneRisposta.getIdMessageRequest();
  4728.         
  4729.         //ProprietaErroreApplicativo proprietaErroreAppl = parametriGestioneRisposta.getProprietaErroreAppl();
  4730.         
  4731.         GestoreMessaggi msgRequest = parametriGestioneRisposta.getMsgRequest();
  4732.         
  4733.         //IDSoggetto identitaPdD = parametriGestioneRisposta.getIdentitaPdD();
  4734.         
  4735.         parametriGestioneRisposta.setPortaStateless(true);
  4736.         
  4737.         boolean rinegoziamentoConnessione = 
  4738.             propertiesReader.isRinegoziamentoConnessione(this.msgContext.getProtocol().getProfiloCollaborazione()) && (!parametriGestioneRisposta.isOneWayVers11());

  4740.         boolean localForward = parametriGestioneRisposta.isLocalForward();
  4741.         
  4742.         // ID Transazione
  4743.         @SuppressWarnings("unused")
  4744.         String idTransazione = PdDContext.getValue(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, imbustamentoMSG.getPddContext());
  4745.         
  4746.         PdDContext pddContext = parametriGestioneRisposta.getPddContext();
  4747.         
  4748.         if(localForward){
  4749.             
  4750.             
  4751.             // E' RicezioneContenutiApplicativi se siamo in oneway11 con presa in carico
  4752.             if( ConsegnaContenutiApplicativi.ID_MODULO.equals( ((OpenSPCoopStateless)openspcoopstate).getDestinatarioRequestMsgLib() )
  4753.                     &&
  4754.                  ((OpenSPCoopStateless)openspcoopstate).getDestinatarioResponseMsgLib()==null ){
  4755.                         
  4756.                 
  4757.                 
  4758.                 /* ------------ Rilascio risorsa se e' presente rinegoziamento delle risorse ------------------ */
  4759.                 // Rinegozio la connessione SOLO se siamo in oneway o sincrono stateless puro (non oneway11)
  4760.                 if( rinegoziamentoConnessione ){
  4761.                     msgDiag.highDebug("ConsegnaContenutiApplicativi stateless (commit) ...");
  4762.                     openspcoopstate.setUseConnection(true);
  4763.                     try{
  4764.                         openspcoopstate.commit();
  4765.                     }catch(Exception e){
  4766.                         // ignore
  4767.                     }
  4768.                     openspcoopstate.releaseResource();
  4769.                     openspcoopstate.setUseConnection(false);
  4770.                 }
  4771.                 
  4772.                 
  4773.                 
  4774.                 /*
  4775.                  * ---------------------- CONSEGNA CONTENUTI APPLICATIVI ------------------
  4776.                  */
  4777.         
  4778.                 ConsegnaContenutiApplicativi consegnaContenutiLib = null;
  4779.                 try {
  4780.                     consegnaContenutiLib = new ConsegnaContenutiApplicativi(logCore);
  4781.                     esito = consegnaContenutiLib.onMessage(openspcoopstate);
  4782.                     if(esito.getStatoInvocazione()==EsitoLib.ERRORE_NON_GESTITO){
  4783.                         if(esito.getErroreNonGestito()!=null)
  4784.                             throw esito.getErroreNonGestito();
  4785.                         else
  4786.                             throw new Exception("Errore non gestito");
  4787.                     }
  4788.                 } catch (Throwable e) {
  4789.                     msgDiag.logErroreGenerico(e,"Stateless.ConsegnaContenutiApplicativi");
  4790.                     logError(logCore, "Errore Generale durante la gestione stateless: "+e.getMessage(),e);
  4791.                     msgRequest.deleteMessageFromFileSystem(); // elimino richiesta salvata precedentemente
  4792.                     openspcoopstate.setUseConnection(true);
  4793.                     openspcoopstate.releaseResource();
  4794.                     if (this.msgContext.isGestioneRisposta()) {
  4795.                         this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,AbstractErrorGenerator.getIntegrationInternalError(pddContext),
  4796.                                 ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreIntegrazione(),e,null)));
  4797.                     }
  4798.                     return false;
  4799.                 }
  4800.                 
  4801.                 if (esito.getStatoInvocazione() != EsitoLib.OK) {
  4802.                     // ripristino utilizzo connessione al database
  4803.                     openspcoopstate.setUseConnection(true);
  4804.                     gestioneRisposta(parametriGestioneRisposta);
  4805.                     return false;
  4806.                 }
  4807.                 
  4808.             }
  4809.     

  4811.             
  4812.         }
  4813.         
  4814.         else{ 
  4815.             /*------------------------------- IMBUSTAMENTO -------------------------------------------*/
  4816.             msgDiag.highDebug("Imbustamento stateless ...");
  4817.             org.openspcoop2.pdd.mdb.Imbustamento imbustamentoLib = null;
  4818.             openspcoopstate.setMessageLib(imbustamentoMSG);
  4819.             openspcoopstate.setIDMessaggioSessione(idMessageRequest);
  4820.             try {
  4821.                 imbustamentoLib = new org.openspcoop2.pdd.mdb.Imbustamento(logCore);
  4822.                 msgDiag.highDebug("Imbustamento stateless (invoco) ...");
  4823.                 esito = imbustamentoLib.onMessage(openspcoopstate);
  4824.                 msgDiag.highDebug("Imbustamento stateless (analizzo esito) ...");
  4825.                 if(esito.getStatoInvocazione()==EsitoLib.ERRORE_NON_GESTITO){
  4826.                     if(esito.getErroreNonGestito()!=null)
  4827.                         throw esito.getErroreNonGestito();
  4828.                     else
  4829.                         throw new Exception("Errore non gestito");
  4830.                 }
  4831.             } catch (Throwable e) {
  4832.                 msgDiag.logErroreGenerico(e,"Stateless.Imbustamento");
  4833.                 logError(logCore, "Errore Generale durante la gestione stateless: "+e.getMessage(),e);
  4834.                 msgRequest.deleteMessageFromFileSystem(); // elimino richiesta salvata precedentemente
  4835.                 openspcoopstate.setUseConnection(true);
  4836.                 openspcoopstate.releaseResource();
  4837.                 if (this.msgContext.isGestioneRisposta()) {
  4838.                     this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,AbstractErrorGenerator.getIntegrationInternalError(pddContext),
  4839.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreIntegrazione(),e,null)));
  4840.                 }
  4841.                 return false;
  4842.             }
  4843.     
  4844.             // Se la chiamata alla libreria imbustamento non ha dato errori procedo con le altre librerie
  4845.             // Altrimenti faccio gestire l'errore prodotto dalla libreria
  4846.             if (esito.getStatoInvocazione() != EsitoLib.OK) {
  4847.                 // ripristino utilizzo connessione al database
  4848.                 openspcoopstate.setUseConnection(true);
  4849.                 gestioneRisposta(parametriGestioneRisposta);
  4850.                 msgDiag.highDebug("Imbustamento stateless (terminato:false)");
  4851.                 return false;
  4852.             }
  4853.     
  4854.             // Gestione oneway versione 11
  4855.             if (openspcoopstate.getDestinatarioResponseMsgLib() != null
  4856.                     && openspcoopstate.getDestinatarioResponseMsgLib().startsWith(RicezioneContenutiApplicativi.ID_MODULO)
  4857.                     && propertiesReader.isGestioneOnewayStateful_1_1()){
  4858.                 msgDiag.highDebug("Imbustamento stateless (terminato:true)");
  4859.                 return true;
  4860.             }
  4861.     
  4862.             /* ------------ Rilascio risorsa se e' presente rinegoziamento delle risorse ------------------ */
  4863.             // Rinegozio la connessione SOLO se siamo in oneway o sincrono stateless puro (non oneway11)
  4864.             if( rinegoziamentoConnessione ){
  4865.                 msgDiag.highDebug("Imbustamento stateless (commit) ...");
  4866.                 openspcoopstate.setUseConnection(true);
  4867.                 try{
  4868.                     openspcoopstate.commit();
  4869.                 }catch(Exception e){
  4870.                     // ignore
  4871.                 }
  4872.                 openspcoopstate.releaseResource();
  4873.                 openspcoopstate.setUseConnection(false);
  4874.             }
  4875.             
  4876.             msgDiag.highDebug("Imbustamento stateless terminato");
  4877.             
  4878.             
  4879.             
  4880.             
  4881.             /*
  4882.              * ---------------------- INOLTRO BUSTE ------------------
  4883.              */
  4884.     
  4885.             msgDiag.highDebug("InoltroBuste stateless ...");
  4886.             InoltroBuste inoltroBusteLib = null;
  4887.             try {
  4888.                 inoltroBusteLib = new InoltroBuste(logCore);
  4889.                 msgDiag.highDebug("InoltroBuste stateless (invoco) ...");
  4890.                 esito = inoltroBusteLib.onMessage(openspcoopstate);
  4891.                 msgDiag.highDebug("InoltroBuste stateless (analizzo esito) ...");
  4892.                 if(esito.getStatoInvocazione()==EsitoLib.ERRORE_NON_GESTITO){
  4893.                     if(esito.getErroreNonGestito()!=null)
  4894.                         throw esito.getErroreNonGestito();
  4895.                     else
  4896.                         throw new Exception("Errore non gestito");
  4897.                 }
  4898.             } catch (Throwable e) {
  4899.                 msgDiag.logErroreGenerico(e,"Stateless.InoltroBuste");
  4900.                 logError(logCore, "Errore Generale durante la gestione stateless: "+e.getMessage(),e);
  4901.                 msgRequest.deleteMessageFromFileSystem(); // elimino richiesta salvata precedentemente
  4902.                 openspcoopstate.setUseConnection(true);
  4903.                 openspcoopstate.releaseResource();
  4904.                 if (this.msgContext.isGestioneRisposta()) {
  4905.                     this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,AbstractErrorGenerator.getIntegrationInternalError(pddContext),
  4906.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreIntegrazione(),e,null)));
  4907.                 }
  4908.                 return false;
  4909.             }
  4910.             
  4911.             if (esito.getStatoInvocazione() != EsitoLib.OK) {
  4912.                 // ripristino utilizzo connessione al database
  4913.                 openspcoopstate.setUseConnection(true);
  4914.                 gestioneRisposta(parametriGestioneRisposta);
  4915.                 msgDiag.highDebug("InoltroBuste stateless (terminato:false)");
  4916.                 return false;
  4917.             }
  4918.     
  4919.             // Gestione oneway versione 11
  4920.             if (openspcoopstate.getDestinatarioResponseMsgLib()!=null &&
  4921.                     openspcoopstate.getDestinatarioResponseMsgLib().startsWith(
  4922.                     RicezioneContenutiApplicativi.ID_MODULO)){
  4923.                 msgDiag.highDebug("InoltroBuste stateless (terminato:true)");
  4924.                 return true;
  4925.             }
  4926.             
  4927.             msgDiag.highDebug("InoltroBuste stateless terminato");
  4928.             
  4929.             
  4930.             
  4931.             
  4932.     
  4933.             /*--------------- SBUSTAMENTO RISPOSTE ---------------- */
  4934.     
  4935.             msgDiag.highDebug("SbustamentoRisposte stateless ...");
  4936.             SbustamentoRisposte sbustamentoRisposteLib = null;
  4937.             boolean erroreSbustamentoRisposta = false;
  4938.             try {
  4939.                 sbustamentoRisposteLib = new SbustamentoRisposte(logCore);
  4940.                 /* Verifico che non abbia rilasciato la connessione, se si la riprendo */
  4941.                 if( rinegoziamentoConnessione && openspcoopstate.resourceReleased()){
  4942.                     /* per default disabilitato 
  4943.                     msgDiag.highDebug("SbustamentoRisposte stateless (initResourceDB) ...");
  4944.                     openspcoopstate.setUseConnection(true);
  4945.                     openspcoopstate.initResource(parametriGestioneRisposta.getIdentitaPdD(), SbustamentoRisposte.ID_MODULO, idTransazione);
  4946.                     openspcoopstate.setUseConnection(false);
  4947.                      */
  4948.                     // update states
  4949.                     registroServiziReader = registroServiziReader.refreshState(openspcoopstate.getStatoRichiesta(),openspcoopstate.getStatoRisposta());
  4950.                     configurazionePdDReader = configurazionePdDReader.refreshState(registroServiziReader);
  4951.                     msgDiag.updateState(configurazionePdDReader);
  4952.                 }
  4953.                 msgDiag.highDebug("SbustamentoRisposte stateless (invoco) ...");
  4954.                 esito = sbustamentoRisposteLib.onMessage(openspcoopstate);
  4955.                 msgDiag.highDebug("SbustamentoRisposte stateless (analizzo esito) ...");
  4956.                 if(esito.getStatoInvocazione()==EsitoLib.ERRORE_NON_GESTITO){
  4957.                     if(esito.getErroreNonGestito()!=null)
  4958.                         throw esito.getErroreNonGestito();
  4959.                     else
  4960.                         throw new Exception("Errore non gestito");
  4961.                 }
  4962.             } catch (Throwable e) {
  4963.                 erroreSbustamentoRisposta = true;
  4964.                 msgDiag.logErroreGenerico(e,"Stateless.SbustamentoRisposte");
  4965.                 logError(logCore, "Errore Generale durante la gestione stateless: "+e.getMessage(),e);
  4966.                 msgRequest.deleteMessageFromFileSystem(); // elimino richiesta salvata precedentemente
  4967.                 openspcoopstate.setUseConnection(true);
  4968.                 openspcoopstate.releaseResource();
  4969.                 if (this.msgContext.isGestioneRisposta()) {
  4970.                     this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,AbstractErrorGenerator.getIntegrationInternalError(pddContext),
  4971.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreIntegrazione(),e,null)));
  4972.                 }
  4973.                 return false;
  4974.             }finally{
  4975.                 /* Se devo rinegoziare la connessione, la rilascio */
  4976.                 if( (rinegoziamentoConnessione) && (erroreSbustamentoRisposta==false) ){
  4977.                     msgDiag.highDebug("SbustamentoRisposte stateless (commit) ...");
  4978.                     openspcoopstate.setUseConnection(true);
  4979.                     try{
  4980.                         openspcoopstate.commit();
  4981.                     }catch(Exception e){
  4982.                         // ignore
  4983.                     }
  4984.                     openspcoopstate.releaseResource();
  4985.                     openspcoopstate.setUseConnection(false);
  4986.                 }
  4987.             }
  4988.     
  4989.             if (esito.getStatoInvocazione() != EsitoLib.OK) {
  4990.                 // ripristino utilizzo connessione al database
  4991.                 openspcoopstate.setUseConnection(true);
  4992.                 gestioneRisposta(parametriGestioneRisposta);
  4993.                 msgDiag.highDebug("SbustamentoRisposte stateless (terminato:false)");
  4994.                 return false;
  4995.             }

  4997.             msgDiag.highDebug("SbustamentoRisposte stateless terminato");
  4998.             
  4999.         }
  5000.         
  5001.         

  5003.         return true;
  5004.     }

  5006.     
  5007.     
  5008.     
  5009.     
  5010.     
  5011.     
  5012.     
  5013.     
  5014.     
  5015.     
  5016.     /*--------------------------------------- GESTIONE RISPOSTA --------------------------- */

  5018.     /* Gestisce le risposte applicative di Ok o di errore */
  5019.     private void gestioneRisposta(RicezioneContenutiApplicativiGestioneRisposta parametriGestioneRisposta){
  5020.             
  5021.             
  5022.         /* ------- Lettura parametri ---------- */
  5023.         IOpenSPCoopState openspcoopstate = parametriGestioneRisposta.getOpenspcoopstate();
  5024.         
  5025.         MsgDiagnostico msgDiag = parametriGestioneRisposta.getMsgDiag();
  5026.         Logger logCore = parametriGestioneRisposta.getLogCore();
  5027.         OpenSPCoop2Properties propertiesReader = parametriGestioneRisposta.getPropertiesReader();
  5028.         
  5029.         IDSoggetto identitaPdD = parametriGestioneRisposta.getIdentitaPdD();
  5030.         String idMessageRequest = parametriGestioneRisposta.getIdMessageRequest();
  5031.         
  5032.         //ProprietaErroreApplicativo proprietaErroreAppl = parametriGestioneRisposta.getProprietaErroreAppl();
  5033.         String servizioApplicativo = parametriGestioneRisposta.getServizioApplicativo();
  5034.         
  5035.         HeaderIntegrazione headerIntegrazioneRichiesta = parametriGestioneRisposta.getHeaderIntegrazioneRichiesta();
  5036.         HeaderIntegrazione headerIntegrazioneRisposta = parametriGestioneRisposta.getHeaderIntegrazioneRisposta();
  5037.         String[] tipiIntegrazionePD = parametriGestioneRisposta.getTipiIntegrazionePD();
  5038.         
  5039.         GestoreMessaggi msgRequest = parametriGestioneRisposta.getMsgRequest();
  5040.         //RepositoryBuste repositoryBuste = parametriGestioneRisposta.getRepositoryBuste();
  5041.         
  5042.         boolean portaStateless = parametriGestioneRisposta.isPortaStateless();
  5043.         boolean oneWayVers11 = parametriGestioneRisposta.isOneWayVers11();
  5044.         boolean richiestaAsincronaSimmetricaStateless = parametriGestioneRisposta.isRichiestaAsincronaSimmetricaStateless();
  5045.         
  5046.         PdDContext pddContext = parametriGestioneRisposta.getPddContext();
  5047.         String idTransazione = PdDContext.getValue(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, pddContext);
  5048.         RequestInfo requestInfo = (RequestInfo) pddContext.getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  5049.         
  5050.         IProtocolFactory<?> protocolFactory = parametriGestioneRisposta.getProtocolFactory();
  5051.         
  5052.         Busta bustaRichiesta = parametriGestioneRisposta.getBustaRichiesta();
  5053.         
  5054.         Loader loader = Loader.getInstance();
  5055.         PddPluginLoader pluginLoader = PddPluginLoader.getInstance();
  5056.         
  5057.         boolean errorOccurs_setResponse = false;

  5059.         /* ------------ GestioneRisposta ------------- */
  5060.         String idMessageResponse = null;
  5061.         String idCollaborazioneResponse = null;
  5062.         ProfiloDiCollaborazione profiloCollaborazione = null;
  5063.         String profiloCollaborazioneValue = null;
  5064.         OpenSPCoop2Message responseMessage = null;
  5065.         String idCorrelazioneApplicativaRisposta = null;
  5066.         //org.openspcoop.pdd.core.TempiAttraversamentoPDD tempiAttraversamentoGestioneMessaggi = null;
  5067.         //org.openspcoop.pdd.core.DimensioneMessaggiAttraversamentoPdD dimensioneMessaggiAttraversamentoGestioneMessaggi = null;
  5068.         try {

  5070.             if (portaStateless || oneWayVers11) {
  5071.                 
  5072.                 // Gestione stateless
  5073.                 
  5074.                 RicezioneContenutiApplicativiMessage ricezioneContenutiApplicativiMSG = 
  5075.                     (RicezioneContenutiApplicativiMessage) ((OpenSPCoopStateless) openspcoopstate).getMessageLib();
  5076.                 idMessageResponse = ricezioneContenutiApplicativiMSG.getIdBustaRisposta();
  5077.                 idCollaborazioneResponse = ricezioneContenutiApplicativiMSG.getIdCollaborazione();
  5078.                 profiloCollaborazione = ricezioneContenutiApplicativiMSG.getProfiloCollaborazione();
  5079.                 profiloCollaborazioneValue = ricezioneContenutiApplicativiMSG.getProfiloCollaborazioneValue();

  5081.                 responseMessage = ((OpenSPCoopStateless) openspcoopstate).getRispostaMsg();
  5082.                 
  5083.                 idCorrelazioneApplicativaRisposta = ((OpenSPCoopStateless) openspcoopstate).getIDCorrelazioneApplicativaRisposta();
  5084.                 
  5085.                 if(ProfiloDiCollaborazione.ONEWAY.equals(profiloCollaborazione)==false){
  5086.                     this.msgContext.getProtocol().setIdRisposta(idMessageResponse);
  5087.                 }
  5088.                 this.msgContext.getProtocol().setCollaborazione(idCollaborazioneResponse);

  5090.                 //tempiAttraversamentoGestioneMessaggi = 
  5091.                 //  ((OpenSPCoopStateless) openspcoopstate).getTempiAttraversamentoPDD();
  5092.                 //dimensioneMessaggiAttraversamentoGestioneMessaggi = 
  5093.                 //  ((OpenSPCoopStateless) openspcoopstate).getDimensioneMessaggiAttraversamentoPDD();

  5095.                 // Aggiornamento Informazioni Protocollo
  5096.                 msgDiag.setIdMessaggioRisposta(idMessageResponse);
  5097.                 msgDiag.addKeyword(CostantiPdD.KEY_ID_MESSAGGIO_RISPOSTA, idMessageResponse);
  5098.             }

  5100.             else {

  5102.                 // Gestione stateful
  5103.                 
  5104.                 try {
  5105.                     responseMessage = MessageUtilities.buildEmptyMessage(OpenSPCoop2MessageFactory.getDefaultMessageFactory(),
  5106.                             requestInfo.getIntegrationRequestMessageType(), MessageRole.RESPONSE);

  5108.                     String classType = null;
  5109.                     INodeReceiver nodeReceiver = null;
  5110.                     try {
  5111.                         classType = ClassNameProperties.getInstance().getNodeReceiver(propertiesReader.getNodeReceiver());
  5112.                         nodeReceiver = (INodeReceiver) loader.newInstance(classType);
  5113.                     } catch (Exception e) {
  5114.                         throw new Exception(
  5115.                                 "Riscontrato errore durante il caricamento della classe ["+ classType
  5116.                                         + "] da utilizzare per la ricezione dall'infrastruttura: "+ e.getMessage());
  5117.                     }
  5118.                     
  5119.                     msgDiag.mediumDebug("Attesa/lettura risposta...");
  5120.                     RicezioneContenutiApplicativiMessage ricezioneContenutiApplicativiMSG = 
  5121.                         (RicezioneContenutiApplicativiMessage) nodeReceiver.receive(
  5122.                                 msgDiag, identitaPdD,this.msgContext.getIdModulo(),idMessageRequest,
  5123.                                     propertiesReader.getNodeReceiverTimeoutRicezioneContenutiApplicativi(),
  5124.                                     propertiesReader.getNodeReceiverCheckInterval());
  5125.                     idMessageResponse = ricezioneContenutiApplicativiMSG.getIdBustaRisposta();
  5126.                     idCollaborazioneResponse = ricezioneContenutiApplicativiMSG.getIdCollaborazione();
  5127.                     profiloCollaborazione = ricezioneContenutiApplicativiMSG.getProfiloCollaborazione();
  5128.                     profiloCollaborazioneValue = ricezioneContenutiApplicativiMSG.getProfiloCollaborazioneValue();

  5130.                     // aggiorno pddContext
  5131.                     pddContext = ricezioneContenutiApplicativiMSG.getPddContext();
  5132.                     if(pddContext!=null){
  5133.                         List<MapKey<String>> enumPddContext = pddContext.keys();
  5134.                         if(enumPddContext!=null && !enumPddContext.isEmpty()) {
  5135.                             for (MapKey<String> key : enumPddContext) {
  5136.                                 //System.out.println("AGGIORNO KEY CONTENTUI ["+key+"]");
  5137.                                 this.msgContext.getPddContext().addObject(key, pddContext.getObject(key));
  5138.                             }
  5139.                         }
  5140.                     }
  5141.                     
  5142.                     if(ProfiloDiCollaborazione.ONEWAY.equals(profiloCollaborazione)==false){
  5143.                         this.msgContext.getProtocol().setIdRisposta(idMessageResponse);
  5144.                     }
  5145.                     this.msgContext.getProtocol().setCollaborazione(idCollaborazioneResponse);

  5147.                 } catch (Exception e) {

  5149.                     logError(logCore, "Gestione risposta ("+ this.msgContext.getIdModulo()+ ") con errore", e);
  5150.                     msgDiag.logErroreGenerico(e,"GestioneRispostaErroreGenerale");
  5151.                     
  5152.                     // per la gestione del timeout ho bisogno di una connessione al database
  5153.                     // In caso di Timeout elimino messaggi di richiesta ancora in processamento.
  5154.                     if (e instanceof NodeTimeoutException) {

  5156.                         // Get Connessione al DB
  5157.                         try {
  5158.                             openspcoopstate.updateResource(idTransazione);
  5159.                         } catch (Exception eDB) {
  5160.                             msgDiag.logErroreGenerico(e,"openspcoopstate.updateResource()");
  5161.                             this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_RESPONSE_ERROR,
  5162.                                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  5163.                                     get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_505_GET_DB_CONNECTION),eDB,
  5164.                                     ((responseMessage!=null && responseMessage.getParseException()!=null)?responseMessage.getParseException():null))));
  5165.                             return;
  5166.                         }

  5168.                         // Eliminazione msg di richiesta
  5169.                         try {
  5170.                             msgDiag.logPersonalizzato("timeoutRicezioneRisposta");
  5171.                             msgRequest.aggiornaProprietarioMessaggio(TimerGestoreMessaggi.ID_MODULO);
  5172.                             openspcoopstate.commit();
  5173.                         } catch (Exception eDel) {
  5174.                             msgDiag.logErroreGenerico(eDel,"EliminazioneMessaggioScadutoTimeoutRicezioneRisposta");
  5175.                         }
  5176.                         // Rilascio connessione
  5177.                         openspcoopstate.releaseResource();
  5178.                     }

  5180.                     this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_RESPONSE_ERROR,
  5181.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  5182.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_513_RECEIVE), e, 
  5183.                             ((responseMessage!=null && responseMessage.getParseException()!=null)?responseMessage.getParseException():null))));
  5184.                     return;
  5185.                 }

  5187.                 // Aggiornamento Informazioni Protocollo
  5188.                 msgDiag.setIdMessaggioRisposta(idMessageResponse);
  5189.                 msgDiag.addKeyword(CostantiPdD.KEY_ID_MESSAGGIO_RISPOSTA, idMessageResponse);

  5191.                 /* ------------ Re-ottengo Connessione al DB -------------- */
  5192.                 msgDiag.mediumDebug("Richiesta connessione al database per la gestione della risposta...");
  5193.                 try {
  5194.                     openspcoopstate.updateResource(idTransazione);
  5195.                 } catch (Exception e) {
  5196.                     msgDiag.logErroreGenerico(e,"openspcoopstate.updateResource()");
  5197.                     this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_RESPONSE_ERROR,
  5198.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  5199.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_505_GET_DB_CONNECTION), e,
  5200.                             ((responseMessage!=null && responseMessage.getParseException()!=null)?responseMessage.getParseException():null))));
  5201.                     return;
  5202.                 }
  5203.                 msgRequest.updateOpenSPCoopState(openspcoopstate);

  5205.                 /*
  5206.                  * ------------ Lettura Contenuto Messaggio (mapping in Message) --------------
  5207.                  */
  5208.                 msgDiag.mediumDebug("Lettura messaggio di risposta...");
  5209.                 GestoreMessaggi msgResponse = new GestoreMessaggi(openspcoopstate, false, idMessageResponse, Costanti.INBOX,msgDiag,this.msgContext.pddContext);
  5210.                 try {
  5211.                     responseMessage = msgResponse.getMessage();
  5212.                     if(responseMessage!=null && this.msgContext.getPddContext()!=null) {
  5213.                         Object o = responseMessage.getContextProperty(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO);
  5214.                         if(o!=null && o instanceof Boolean) {
  5215.                             this.msgContext.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO, true);
  5216.                         }
  5217.                         o = responseMessage.getContextProperty(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO_PARSE_EXCEPTION);
  5218.                         if(o!=null && o instanceof ParseException) {
  5219.                             this.msgContext.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RICHIESTA_NON_RICONOSCIUTO_PARSE_EXCEPTION, o);
  5220.                         }
  5221.                         
  5222.                         o = responseMessage.getContextProperty(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO);
  5223.                         if(o!=null && o instanceof Boolean) {
  5224.                             this.msgContext.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO, true);
  5225.                         }
  5226.                         o = responseMessage.getContextProperty(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO_PARSE_EXCEPTION);
  5227.                         if(o!=null && o instanceof ParseException) {
  5228.                             this.msgContext.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO_PARSE_EXCEPTION, o);
  5229.                         }
  5230.                     }
  5231.                     idCorrelazioneApplicativaRisposta = msgResponse.getIDCorrelazioneApplicativaRisposta();
  5232.                     
  5233.                     /*tempiAttraversamentoGestioneMessaggi = msgResponse.getTempiAttraversamentoPdD();
  5234.                     if (tempiAttraversamentoGestioneMessaggi != null
  5235.                             && (tempiAttraversamentoGestioneMessaggi.getRicezioneMsgIngresso()==null || tempiAttraversamentoGestioneMessaggi.getSpedizioneMessaggioIngresso()==null)) {
  5236.                         TempiAttraversamentoPDD dRichiesta = msgRequest.getTempiAttraversamentoPdD();
  5237.                         if (dRichiesta != null) {
  5238.                             tempiAttraversamentoGestioneMessaggi.setSpedizioneMessaggioIngresso(dRichiesta.getSpedizioneMessaggioIngresso());
  5239.                         }
  5240.                     }
  5241.                     
  5242.                     dimensioneMessaggiAttraversamentoGestioneMessaggi = msgResponse.getDimensioneMessaggiAttraversamentoPdD();*/

  5244.                 } catch (GestoreMessaggiException e) {
  5245.                     msgDiag.logErroreGenerico(e,"msgResponse.getMessage()");
  5246.                     openspcoopstate.releaseResource();
  5247.                     this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_RESPONSE_ERROR,
  5248.                             ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.
  5249.                             get5XX_ErroreProcessamento(CodiceErroreIntegrazione.CODICE_511_READ_RESPONSE_MSG), e,
  5250.                             ((responseMessage!=null && responseMessage.getParseException()!=null)?responseMessage.getParseException():null))));
  5251.                     return;
  5252.                 }

  5254.             }
  5255.         } catch (Exception e) {
  5256.             logError(logCore, "ErroreGenerale", e);
  5257.             msgDiag.logErroreGenerico(e,"ErroreGenerale");
  5258.             openspcoopstate.releaseResource();
  5259.             this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_RESPONSE_ERROR,
  5260.                     ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreIntegrazione(), e,
  5261.                     ((responseMessage!=null && responseMessage.getParseException()!=null)?responseMessage.getParseException():null))
  5262.                     ));
  5263.             errorOccurs_setResponse = true;
  5264.         }

  5266.         
  5267.         
  5268.         /* ---- Aggiorno informazioni correlazione applicativa risposta ---- */
  5269.         msgDiag.setIdCorrelazioneRisposta(idCorrelazioneApplicativaRisposta);
  5270.         if(this.msgContext.getProtocol()!=null){
  5271.             this.msgContext.getProtocol().setProfiloCollaborazione(profiloCollaborazione, profiloCollaborazioneValue);
  5272.         }
  5273.         if(this.msgContext.getIntegrazione()!=null)
  5274.             this.msgContext.getIntegrazione().setIdCorrelazioneApplicativaRisposta(idCorrelazioneApplicativaRisposta);
  5275.             
  5276.         
  5277.         
  5278.         
  5279.         /* ----- Header Integrazione ------ */
  5280.         msgDiag.mediumDebug("Gestione header di integrazione messaggio di risposta...");
  5281.         headerIntegrazioneRisposta.getBusta().setIdCollaborazione(idCollaborazioneResponse);
  5282.         headerIntegrazioneRisposta.getBusta().setProfiloDiCollaborazione(profiloCollaborazione);

  5284.         // -- REFRESH Impostation Risposta dell'Header Trasporto o se l'invocazione e' stata attiva dall'IntegrationManager --
  5285.         // Refresh necessario in seguito alla potenziale impostazione della collaborazione e Profilo di Collaborazione
  5286.         // ed eventuali altre future informazioni non subito disponibili
  5287.         
  5288.         String jtiIdModIRequest = null;
  5289.         Object bustaRispostaObject = null;
  5290.         if(pddContext!=null) {
  5291.             if(pddContext.containsKey(org.openspcoop2.core.constants.Costanti.MODI_JTI_REQUEST_ID)) {
  5292.                 jtiIdModIRequest = (String) pddContext.get(org.openspcoop2.core.constants.Costanti.MODI_JTI_REQUEST_ID);
  5293.             }
  5294.             if(pddContext.containsKey(CostantiPdD.BUSTA_RISPOSTA)) {
  5295.                 bustaRispostaObject = pddContext.getObject(CostantiPdD.BUSTA_RISPOSTA);
  5296.             }
  5297.         }
  5298.         if(jtiIdModIRequest!=null && StringUtils.isNotEmpty(jtiIdModIRequest) && !jtiIdModIRequest.equals(idMessageRequest)) {
  5299.             headerIntegrazioneRisposta.getBusta().setID(jtiIdModIRequest);
  5300.         }
  5301.         else {
  5302.             headerIntegrazioneRisposta.getBusta().setID(idMessageRequest);
  5303.         }
  5304.         OutResponsePDMessage outResponsePDMessage = new OutResponsePDMessage();
  5305.         outResponsePDMessage.setBustaRichiesta(bustaRichiesta);
  5306.         if(bustaRispostaObject instanceof Busta){
  5307.             Busta bustaRisposta = (Busta) bustaRispostaObject;
  5308.             // aggiungo proprieta' (vengono serializzate negli header di integrazione)
  5309.             if(bustaRisposta.sizeProperties()>0){
  5310.                 String[]propertyNames = bustaRisposta.getPropertiesNames();
  5311.                 for (int i = 0; i < propertyNames.length; i++) {
  5312.                     outResponsePDMessage.getBustaRichiesta().addProperty(propertyNames[i], bustaRisposta.getProperty(propertyNames[i]));
  5313.                 }
  5314.             }
  5315.         }
  5316.         outResponsePDMessage.setMessage(responseMessage);
  5317.         outResponsePDMessage.setPortaDelegata(parametriGestioneRisposta.getPortaDelegata());
  5318.         Map<String, List<String>> propertiesIntegrazioneRisposta = new HashMap<>();
  5319.         outResponsePDMessage.setHeaders(propertiesIntegrazioneRisposta);
  5320.         outResponsePDMessage.setServizio(parametriGestioneRisposta.getIdServizio());
  5321.         outResponsePDMessage.setSoggettoMittente(parametriGestioneRisposta.getSoggettoMittente());

  5323.         if (this.msgContext.getIdModulo().startsWith(RicezioneContenutiApplicativi.ID_MODULO+ IntegrationManager.ID_MODULO)) {
  5324.             try {
  5325.                 IGestoreIntegrazionePD gestore = null;
  5326.                 try {
  5327.                     gestore = (IGestoreIntegrazionePD) pluginLoader.newIntegrazionePortaDelegata(CostantiConfigurazione.HEADER_INTEGRAZIONE_TRASPORTO);
  5328.                 }catch(Exception e){
  5329.                     throw e;
  5330.                 }
  5331.                 if(gestore!=null){
  5332.                     String classType = null;
  5333.                     try {
  5334.                         classType = gestore.getClass().getName();
  5335.                         AbstractCore.init(gestore, pddContext, protocolFactory);
  5336.                     } catch (Exception e) {
  5337.                         throw new Exception(
  5338.                                 "Riscontrato errore durante l'inizializzazione della classe ["+ classType
  5339.                                         + "] da utilizzare per la gestione dell'integrazione delle fruizioni (Risposta IM) di tipo ["+ CostantiConfigurazione.HEADER_INTEGRAZIONE_TRASPORTO + "]: " + e.getMessage());
  5340.                     }

  5342.                     gestore.setOutResponseHeader(headerIntegrazioneRisposta, outResponsePDMessage);
  5343.                 }
  5344.             } catch (Exception e) {
  5345.                 msgDiag.logErroreGenerico(e,"setHeaderIntegrazioneRisposta");
  5346.             }
  5347.         }

  5349.         // HeaderIntegrazione
  5350.         for (int i = 0; i < tipiIntegrazionePD.length; i++) {
  5351.             try {
  5352.                 IGestoreIntegrazionePD gestore = null;
  5353.                 try {
  5354.                     gestore = (IGestoreIntegrazionePD) pluginLoader.newIntegrazionePortaDelegata(tipiIntegrazionePD[i]);
  5355.                 }catch(Exception e){
  5356.                     throw e;
  5357.                 }
  5358.                 if(gestore!=null){
  5359.                     String classType = null;
  5360.                     try {
  5361.                         classType = gestore.getClass().getName();
  5362.                         AbstractCore.init(gestore, pddContext, protocolFactory);
  5363.                     } catch (Exception e) {
  5364.                         throw new Exception(
  5365.                                 "Riscontrato errore durante l'inizializzazione della classe ["+ classType
  5366.                                         + "] da utilizzare per la gestione dell'integrazione delle fruizioni (Risposta) di tipo ["+ tipiIntegrazionePD[i] + "]: " + e.getMessage());
  5367.                     }
  5368.                     if(gestore instanceof IGestoreIntegrazionePDSoap){
  5369.                         if(propertiesReader.processHeaderIntegrazionePDResponse(false)){
  5370.                             if(propertiesReader.deleteHeaderIntegrazioneResponsePD()){
  5371.                                 if(responseMessage==null){
  5372.                                     responseMessage = MessageUtilities.buildEmptyMessage(OpenSPCoop2MessageFactory.getDefaultMessageFactory(),
  5373.                                             requestInfo.getIntegrationRequestMessageType(), MessageRole.RESPONSE);
  5374.                                     outResponsePDMessage.setMessage(responseMessage);
  5375.                                 }
  5376.                                 gestore.setOutResponseHeader(headerIntegrazioneRisposta,outResponsePDMessage);
  5377.                             }else{
  5378.                                 // gia effettuato l'update dell'header in InoltroBuste
  5379.                             }
  5380.                         }else{
  5381.                             if(responseMessage==null){
  5382.                                 responseMessage = MessageUtilities.buildEmptyMessage(OpenSPCoop2MessageFactory.getDefaultMessageFactory(),
  5383.                                         requestInfo.getIntegrationRequestMessageType(), MessageRole.RESPONSE);
  5384.                                 outResponsePDMessage.setMessage(responseMessage);
  5385.                             }
  5386.                             gestore.setOutResponseHeader(headerIntegrazioneRisposta,outResponsePDMessage);
  5387.                         }
  5388.                     }else{
  5389.                         gestore.setOutResponseHeader(headerIntegrazioneRisposta,outResponsePDMessage);
  5390.                     }
  5391.                 } else {
  5392.                     throw new Exception("Gestore non inizializzato");
  5393.                 }
  5394.             } catch (Exception e) {
  5395.                 msgDiag.addKeyword(CostantiPdD.KEY_TIPO_HEADER_INTEGRAZIONE,tipiIntegrazionePD[i]);
  5396.                 msgDiag.addKeywordErroreProcessamento(e);
  5397.                 msgDiag.logPersonalizzato("headerIntegrazione.creazioneFallita");
  5398.                 logError(logCore, msgDiag.getMessaggio_replaceKeywords("headerIntegrazione.creazioneFallita"), e);
  5399.             }
  5400.         }

  5402.         // Imposto header di trasporto per la risposta
  5403.         this.msgContext.setResponseHeaders(propertiesIntegrazioneRisposta);
  5404.         
  5405.         
  5406.         
  5407.         
  5408.         
  5409.         
  5410.         
  5411.         /* ----- Eliminazione SIL (Stateful) ------ */
  5412.         
  5413.         if (!portaStateless)
  5414.             eliminaSIL((OpenSPCoopStateful) openspcoopstate, msgDiag, idMessageRequest, idMessageResponse,
  5415.                     servizioApplicativo);

  5417.         
  5418.         
  5419.         
  5420.         /* ----- Aggiornamento proprietario (Stateless puro, no gestione oneway) ------ */
  5421.         if (portaStateless && !oneWayVers11) {
  5422.             msgDiag.mediumDebug("Aggiorno proprietario messaggio richiesta ...");
  5423.             try {
  5424.                 /* Lo stateless che non รจ onewayVersione11 non salva niente su database */
  5425.                 // A meno che non siamo in asincrono simmetrico richiesta stateless
  5426.                 // In caso di richiestaAsincronaSimmetrica e openspcoop stateless,
  5427.                 // Devo comunque salvare le informazioni sul msg della ricevuta alla richiesta.
  5428.                 // Tali informazioni servono per il check nel modulo RicezioneBuste, per verificare di gestire la risposta
  5429.                 // solo dopo aver terminato di gestire la richiesta con relativa ricevuta.
  5430.                 if(richiestaAsincronaSimmetricaStateless){
  5431.                     boolean resourceReleased = openspcoopstate.resourceReleased();
  5432.                     if(resourceReleased){
  5433.                         ((OpenSPCoopStateless)openspcoopstate).setUseConnection(true);
  5434.                         openspcoopstate.updateResource(idTransazione);
  5435.                     }
  5436.                     GestoreMessaggi msgResponse = new GestoreMessaggi(openspcoopstate, false, idMessageResponse, Costanti.INBOX,msgDiag,this.msgContext.pddContext);
  5437.                     msgResponse.setReadyForDrop(true);
  5438.                     msgResponse.aggiornaProprietarioMessaggio(TimerGestoreMessaggi.ID_MODULO);
  5439.                     msgResponse.setReadyForDrop(false);
  5440.                     
  5441.                     // Devo eliminare anche la richiesta (nel caso in cui non sia arrivata la validazione della ricevuta)
  5442.                     msgRequest.updateOpenSPCoopState(openspcoopstate);
  5443.                     msgRequest.setReadyForDrop(true);
  5444.                     msgRequest.aggiornaProprietarioMessaggio(TimerGestoreMessaggi.ID_MODULO);
  5445.                     msgRequest.setReadyForDrop(false);
  5446.                 }
  5447.                 
  5448.                 // Committo modifiche (I commit servono per eventuali modifiche ai duplicati)
  5449.                 openspcoopstate.commit();
  5450.                 
  5451.             } catch (Exception e) {
  5452.                 logError(logCore, "Errore durante l'aggiornamento del proprietario al GestoreMessaggi (Stateless)", e);
  5453.                 msgDiag.logErroreGenerico(e, "openspcoopstate.commit(stateless risposta)");
  5454.                 openspcoopstate.releaseResource();
  5455.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_RESPONSE_ERROR,
  5456.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreIntegrazione(), e,
  5457.                         ((responseMessage!=null && responseMessage.getParseException()!=null)?responseMessage.getParseException():null))));
  5458.                 errorOccurs_setResponse = true;
  5459.             }
  5460.         }

  5462.         
  5463.         
  5464.         /* ----- OneWay stateful/stateless ------ */
  5465.         
  5466.         if (oneWayVers11) {
  5467.             msgDiag.mediumDebug("Commit della gestione oneWay stateful/stateless...");
  5468.             try {
  5469.                 // Committo modifiche
  5470.                 openspcoopstate.commit();
  5471.             } catch (Exception e) {
  5472.                 logError(logCore, "Riscontrato errore durante il commit della gestione oneWay stateful/stateless", e);
  5473.                 msgDiag.logErroreGenerico(e, "openspcoopstate.commit(oneway1.1 risposta)");
  5474.                 openspcoopstate.releaseResource();
  5475.                 this.msgContext.setMessageResponse((this.generatoreErrore.build(pddContext,IntegrationFunctionError.INTERNAL_RESPONSE_ERROR,
  5476.                         ErroriIntegrazione.ERRORE_5XX_GENERICO_PROCESSAMENTO_MESSAGGIO.getErroreIntegrazione(), e,
  5477.                         ((responseMessage!=null && responseMessage.getParseException()!=null)?responseMessage.getParseException():null))));
  5478.                 errorOccurs_setResponse = true;
  5479.             }
  5480.         }

  5482.         
  5483.         
  5484.         
  5485.         
  5486.         /* ----- Terminazione gestione richiesta ------ */
  5487.         
  5488.         // Rilascio connessione al DB
  5489.         msgDiag.mediumDebug("Rilascio connessione al database...");
  5490.         openspcoopstate.releaseResource();

  5492.         // Risposta
  5493.         if (profiloCollaborazione != null) {
  5494.             if (profiloCollaborazione.equals(ProfiloDiCollaborazione.SINCRONO)) {
  5495.                 msgDiag.addKeyword(CostantiPdD.KEY_TIPOLOGIA_RISPOSTA_APPLICATIVA, "risposta sincrona");
  5496.                 msgDiag.logPersonalizzato("consegnaRispostaApplicativa");
  5497.             } else if (profiloCollaborazione.equals(ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO)) {
  5498.                 if (headerIntegrazioneRichiesta != null
  5499.                         && headerIntegrazioneRichiesta.getBusta() != null
  5500.                         && headerIntegrazioneRichiesta.getBusta().getRiferimentoMessaggio() != null) {
  5501.                     msgDiag.addKeyword(CostantiPdD.KEY_TIPOLOGIA_RISPOSTA_APPLICATIVA, "ricevuta di una risposta asincrona simmetrica");
  5502.                 } else {
  5503.                     msgDiag.addKeyword(CostantiPdD.KEY_TIPOLOGIA_RISPOSTA_APPLICATIVA, "ricevuta di una richiesta asincrona simmetrica");
  5504.                 }
  5505.                 msgDiag.logPersonalizzato("consegnaRispostaApplicativa");
  5506.             } else if (profiloCollaborazione.equals(ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO)) {
  5507.                 if (headerIntegrazioneRichiesta != null
  5508.                         && headerIntegrazioneRichiesta.getBusta() != null
  5509.                         && headerIntegrazioneRichiesta.getBusta().getRiferimentoMessaggio() != null) {
  5510.                     msgDiag.addKeyword(CostantiPdD.KEY_TIPOLOGIA_RISPOSTA_APPLICATIVA, "ricevuta di una risposta asincrona asimmetrica");
  5511.                 } else {
  5512.                     msgDiag.addKeyword(CostantiPdD.KEY_TIPOLOGIA_RISPOSTA_APPLICATIVA, "ricevuta di una richiesta asincrona asimmetrica");
  5513.                 }
  5514.                 msgDiag.logPersonalizzato("consegnaRispostaApplicativa");
  5515.             }
  5516.         }

  5518.         
  5519.         
  5520.         
  5521.         msgDiag.mediumDebug("Imposto risposta nel context...");
  5522.         if(errorOccurs_setResponse==false){
  5523.             this.msgContext.setMessageResponse(responseMessage);
  5524.         }

  5526.     }

  5528.     
  5529.     
  5530.     
  5531.     
  5532.     /* -------------- UTILITY -------------- */
  5533.     
  5534.     private void eliminaSIL(OpenSPCoopStateful openspcoopstate,
  5535.             MsgDiagnostico msgDiag, String idMessageRequest, String idMessageResponse,
  5536.             String servizioApplicativo) {
  5537.         // Elimino SIL destinatario a cui ho consegnato il messaggio
  5538.         msgDiag.mediumDebug("Eliminazione SIL destinatario del messaggio nella tabelle MSG_SERVIZI_APPLICATIVI...");
  5539.         if (openspcoopstate.getConnectionDB() != null) {
  5540.             try {
  5541.                 // GestoreMessaggi gestoreEliminazioneDestinatario = new
  5542.                 // GestoreMessaggi(openspcoopstate,
  5543.                 // false,idMessageResponse,Costanti.INBOX,msgDiag);
  5544.                 GestoreMessaggi gestoreEliminazioneDestinatario = new GestoreMessaggi(openspcoopstate, false, idMessageResponse, Costanti.INBOX,msgDiag,this.msgContext.pddContext);
  5545.                 gestoreEliminazioneDestinatario.eliminaDestinatarioMessaggio(servizioApplicativo, idMessageRequest);
  5546.             } catch (Exception e) {
  5547.                 msgDiag.logErroreGenerico(e, "gestoreEliminazioneDestinatario.eliminaDestinatarioMessaggio("+servizioApplicativo+")");
  5548.             }
  5549.         } else {
  5550.             msgDiag.logErroreGenerico("Connessione non disponibile", "gestoreEliminazioneDestinatario.eliminaDestinatarioMessaggio("+servizioApplicativo+")");
  5551.         }
  5552.     }

  5554. }
Created with JaCoCo 0.8.8.202204050719