ConnettoreBase.java

  1. /*
  2.  * GovWay - A customizable API Gateway 
  3.  * https://govway.org
  4.  * 
  5.  * Copyright (c) 2005-2025 Link.it srl (https://link.it). 
  6.  * 
  7.  * This program is free software: you can redistribute it and/or modify
  8.  * it under the terms of the GNU General Public License version 3, as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  *
  19.  */

  21. package org.openspcoop2.pdd.core.connettori;

  23. import java.io.File;
  24. import java.io.InputStream;
  25. import java.text.SimpleDateFormat;
  26. import java.util.ArrayList;
  27. import java.util.Date;
  28. import java.util.HashMap;
  29. import java.util.Iterator;
  30. import java.util.List;
  31. import java.util.Map;

  33. import org.apache.commons.lang.StringUtils;
  34. import org.openspcoop2.core.config.DumpConfigurazione;
  35. import org.openspcoop2.core.config.InvocazioneCredenziali;
  36. import org.openspcoop2.core.config.PortaApplicativa;
  37. import org.openspcoop2.core.config.PortaDelegata;
  38. import org.openspcoop2.core.config.Proprieta;
  39. import org.openspcoop2.core.config.ResponseCachingConfigurazione;
  40. import org.openspcoop2.core.config.ResponseCachingConfigurazioneControl;
  41. import org.openspcoop2.core.config.ResponseCachingConfigurazioneRegola;
  42. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  43. import org.openspcoop2.core.config.constants.StatoFunzionalita;
  44. import org.openspcoop2.core.constants.Costanti;
  45. import org.openspcoop2.core.constants.CostantiConnettori;
  46. import org.openspcoop2.core.constants.TipoPdD;
  47. import org.openspcoop2.core.id.IDAccordo;
  48. import org.openspcoop2.core.id.IDPortaApplicativa;
  49. import org.openspcoop2.core.id.IDPortaDelegata;
  50. import org.openspcoop2.core.id.IDSoggetto;
  51. import org.openspcoop2.core.transazioni.constants.TipoMessaggio;
  52. import org.openspcoop2.message.OpenSPCoop2Message;
  53. import org.openspcoop2.message.OpenSPCoop2MessageProperties;
  54. import org.openspcoop2.message.constants.MessageRole;
  55. import org.openspcoop2.message.constants.MessageType;
  56. import org.openspcoop2.message.constants.ServiceBinding;
  57. import org.openspcoop2.message.exception.ParseExceptionUtils;
  58. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  59. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  60. import org.openspcoop2.pdd.core.AbstractCore;
  61. import org.openspcoop2.pdd.core.CostantiPdD;
  62. import org.openspcoop2.pdd.core.PdDContext;
  63. import org.openspcoop2.pdd.core.controllo_traffico.PolicyTimeoutConfig;
  64. import org.openspcoop2.pdd.core.controllo_traffico.SogliaDimensioneMessaggio;
  65. import org.openspcoop2.pdd.core.dynamic.DynamicInfo;
  66. import org.openspcoop2.pdd.core.dynamic.DynamicUtils;
  67. import org.openspcoop2.pdd.core.handlers.GestoreHandlers;
  68. import org.openspcoop2.pdd.core.handlers.HandlerException;
  69. import org.openspcoop2.pdd.core.handlers.OutRequestContext;
  70. import org.openspcoop2.pdd.core.handlers.PostOutRequestContext;
  71. import org.openspcoop2.pdd.core.handlers.PreInResponseContext;
  72. import org.openspcoop2.pdd.core.response_caching.GestoreCacheResponseCaching;
  73. import org.openspcoop2.pdd.core.response_caching.ResponseCached;
  74. import org.openspcoop2.pdd.core.token.EsitoNegoziazioneToken;
  75. import org.openspcoop2.pdd.core.token.GestoreToken;
  76. import org.openspcoop2.pdd.core.token.PolicyNegoziazioneToken;
  77. import org.openspcoop2.pdd.core.transazioni.Transaction;
  78. import org.openspcoop2.pdd.core.transazioni.TransactionContext;
  79. import org.openspcoop2.pdd.core.transazioni.TransactionNotExistsException;
  80. import org.openspcoop2.pdd.logger.MsgDiagnostico;
  81. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  82. import org.openspcoop2.pdd.logger.transazioni.ConfigurazioneTracciamento;
  83. import org.openspcoop2.pdd.mdb.ConsegnaContenutiApplicativi;
  84. import org.openspcoop2.protocol.sdk.Busta;
  85. import org.openspcoop2.protocol.sdk.dump.DumpException;
  86. import org.openspcoop2.protocol.sdk.dump.Messaggio;
  87. import org.openspcoop2.protocol.sdk.state.IState;
  88. import org.openspcoop2.protocol.sdk.state.RequestInfo;
  89. import org.openspcoop2.protocol.utils.ModIUtils;
  90. import org.openspcoop2.protocol.utils.ModIValidazioneSemanticaProfiloSicurezza;
  91. import org.openspcoop2.utils.MapKey;
  92. import org.openspcoop2.utils.NameValue;
  93. import org.openspcoop2.utils.Utilities;
  94. import org.openspcoop2.utils.date.DateManager;
  95. import org.openspcoop2.utils.date.DateUtils;
  96. import org.openspcoop2.utils.io.DumpByteArrayOutputStream;
  97. import org.openspcoop2.utils.io.notifier.NotifierInputStreamParams;
  98. import org.openspcoop2.utils.resources.Loader;
  99. import org.openspcoop2.utils.transport.TransportUtils;
  100. import org.openspcoop2.utils.transport.http.HttpConstants;
  101. import org.openspcoop2.utils.transport.http.HttpUtilities;
  102. import org.slf4j.Logger;

  104. /** 
  105.  * Contiene una classe base per i connettori
  106.  *
  107.  * @author Poli Andrea (apoli@link.it)
  108.  * @author $Author$
  109.  * @version $Rev$, $Date$
  110.  */
  111. public abstract class ConnettoreBase extends AbstractCore implements IConnettore {

  113.     public static final MapKey<String> RESPONSE_FROM_CACHE = org.openspcoop2.utils.Map.newMapKey("RESPONSE_READED_FROM_CACHE");
  114.     public static final String LOCATION_CACHED = "govway://responseCaching";
  115.     public static final String LOCATION_CACHED_SEPARATOR_REQUEST_URL = "\n";
  116.     
  117.     /** Proprieta' del connettore */
  118.     protected java.util.Map<String,String> properties;
  119.     
  120.     /** Tipo di Connettore */
  121.     protected String tipoConnettore;
  122.     
  123.     /** Msg di richiesta */
  124.     protected OpenSPCoop2Message requestMsg;    
  125.     protected boolean isSoap = false;
  126.     protected boolean isRest = false;
  127.     
  128.     /** Indicazione su di un eventuale sbustamento SOAP */
  129.     protected boolean sbustamentoSoap;
  130.     
  131.     /** Proprieta' del trasporto che deve gestire il connettore */
  132.     protected Map<String, List<String>> propertiesTrasporto;
  133.     
  134.     /** Proprieta' urlBased che deve gestire il connettore */
  135.     protected Map<String, List<String>> propertiesUrlBased;
  136.     
  137.     /** Tipo di Autenticazione */
  138.     //private String tipoAutenticazione;
  139.     /** Credenziali per l'autenticazione */
  140.     protected InvocazioneCredenziali credenziali;
  141.     
  142.     /** Busta */
  143.     protected Busta busta;
  144.     
  145.     /** Indicazione se siamo in modalita' debug */
  146.     protected boolean debug = false;

  148.     /** OpenSPCoopProperties */
  149.     protected OpenSPCoop2Properties openspcoopProperties = null;

  151.     /** Identificativo */
  152.     protected String idMessaggio;
  153.     
  154.     /** Logger */
  155.     protected ConnettoreLogger logger = null;

  157.     /** Loader loader */
  158.     protected Loader loader = null;
  159.     
  160.     /** Errore generato con un prefisso del connettore */
  161.     protected boolean generateErrorWithConnectorPrefix = true;
  162.     
  163.     /** Identificativo Modulo */
  164.     protected String idModulo = null;
  165.     
  166.     /** motivo di un eventuale errore */
  167.     protected String errore = null;
  168.     /** Messaggio di risposta */
  169.     protected OpenSPCoop2Message responseMsg = null;
  170.     /** Codice Operazione Effettuata */
  171.     protected int codice;
  172.     /** ContentLength */
  173.     protected long contentLength = -1;
  174.     /** File tmp */
  175.     protected String location = null;
  176.     /** Eccezione processamento */
  177.     protected Exception eccezioneProcessamento = null;
  178.     /** Proprieta' del trasporto della risposta */
  179.     protected Map<String, List<String>> propertiesTrasportoRisposta = new HashMap<>();
  180.     /** CreationDate */
  181.     protected Date creationDate;
  182.     
  183.     /** MessaggioDiagnostico */
  184.     protected MsgDiagnostico msgDiagnostico;
  185.     /** OutRequestContext */
  186.     protected OutRequestContext outRequestContext;
  187.     /** PostOutRequestContext */
  188.     protected PostOutRequestContext postOutRequestContext;
  189.     /** PreInResponseContext */
  190.     protected PreInResponseContext preInResponseContext;
  191.     /** State */
  192.     protected IState state;
  193.     
  194.     /** SOAPAction */
  195.     protected String soapAction = null;
  196.     
  197.     /** RequestInfo */
  198.     protected RequestInfo requestInfo;
  199.     
  200.     /** Caching Response */
  201.     private boolean responseAlready = false;
  202.     private ResponseCachingConfigurazione responseCachingConfig = null;
  203.     private String responseCachingDigest = null;

  205.     /** Policy Token */
  206.     private PolicyNegoziazioneToken policyNegoziazioneToken;
  207.     protected PolicyTimeoutConfig policyTimeoutConfig;
  208.     
  209.     protected Date dataRichiestaInoltrata;
  210.     @Override
  211.     public Date getDataRichiestaInoltrata() {
  212.         return this.dataRichiestaInoltrata;
  213.     }
  214.     
  215.     protected Date dataAccettazioneRisposta;
  216.     @Override
  217.     public Date getDataAccettazioneRisposta(){
  218.         return this.dataAccettazioneRisposta;
  219.     }
  220.     
  221.     protected DumpRaw dumpRaw = null;
  222.     protected boolean logFileTrace_headers = false;
  223.     protected boolean logFileTrace_payload = false;
  224.     
  225.     private boolean registerSendIntoContext = true;
  226.     public void setRegisterSendIntoContext(boolean registerSendIntoContext) {
  227.         this.registerSendIntoContext = registerSendIntoContext;
  228.     }

  230.     private IDAccordo idAccordo = null;
  231.     protected IDAccordo getIdAccordo() {
  232.         return this.idAccordo;
  233.     }

  235.     protected String idTransazione;
  236.     
  237.     protected int dumpBinario_soglia;
  238.     protected File dumpBinario_repositoryFile;
  239.     
  240.     protected PortaApplicativa pa;
  241.     protected String nomeConnettoreAsincrono;
  242.     protected PortaDelegata pd;
  243.     
  244.     protected boolean useTimeoutInputStream = false;
  245.     
  246.     protected boolean useLimitedInputStream = false;
  247.     protected SogliaDimensioneMessaggio limitBytes = null;
  248.     
  249.     protected boolean useDiagnosticInputStream = false;
  250.     
  251.     protected List<Proprieta> proprietaPorta;
  252.     
  253.     protected ConnettoreBase(){
  254.         this.creationDate = DateManager.getDate();
  255.     }
  256.     
  257.     public void setPa(PortaApplicativa pa) {
  258.         this.pa = pa;
  259.     }

  261.     public void setPd(PortaDelegata pd) {
  262.         this.pd = pd;
  263.     }
  264.     
  265.     protected boolean initialize(ConnettoreMsg request, boolean connectorPropertiesRequired, ResponseCachingConfigurazione responseCachingConfig){
  266.         
  267.         this.openspcoopProperties = OpenSPCoop2Properties.getInstance();
  268.         this.loader = Loader.getInstance();

  270.         if(request==null){
  271.             this.errore = "Messaggio da consegnare is Null (ConnettoreMsg)";
  272.             return false;
  273.         }
  274.         
  275.         // Raccolta parametri per costruttore logger
  276.         this.properties = request.getConnectorProperties();
  277.         if(connectorPropertiesRequired){
  278.             if(this.properties == null)
  279.                 this.errore = "Proprieta' del connettore non definite";
  280.             else if(this.properties.size() == 0)
  281.                 this.errore = "Proprieta' del connettore non definite";
  282.         }
  283.         
  284.         // tipoConnetore
  285.         this.tipoConnettore = request.getTipoConnettore();
  286.         
  287.         // generateErrorWithConnectorPrefix
  288.         this.generateErrorWithConnectorPrefix = request.isGenerateErrorWithConnectorPrefix();
  289.         
  290.         // - Busta
  291.         this.busta = request.getBusta();
  292.         if(this.busta!=null)
  293.             this.idMessaggio=this.busta.getID();
  294.         
  295.         // - Debug mode
  296.         if(this.properties!=null && this.properties.get(CostantiConnettori.CONNETTORE_DEBUG)!=null){
  297.             if("true".equalsIgnoreCase(this.properties.get(CostantiConnettori.CONNETTORE_DEBUG).trim()))
  298.                 this.debug = true;
  299.         }
  300.     
  301.         // Logger
  302.         this.logger = new ConnettoreLogger(this.debug, this.idMessaggio, this.getPddContext());
  303.         
  304.         // MessageConfiguration
  305.         if(this.getPddContext()!=null && this.getPddContext().containsKey(org.openspcoop2.core.constants.Costanti.REQUEST_INFO)){
  306.             this.requestInfo = (RequestInfo) this.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.REQUEST_INFO);
  307.         }
  308.         
  309.         // State
  310.         this.state = request.getState();
  311.         
  312.         // Raccolta altri parametri
  313.         try{
  314.             this.requestMsg =  request.getRequestMessage(this.requestInfo, this.getPddContext());
  315.         }catch(Exception e){
  316.             this.eccezioneProcessamento = e;
  317.             this.logger.error("Errore durante la lettura del messaggio da consegnare: "+this.readExceptionMessageFromException(e),e);
  318.             this.errore = "Errore durante la lettura del messaggio da consegnare: "+this.readExceptionMessageFromException(e);
  319.             return false;
  320.         }
  321.         if(this.requestMsg==null){
  322.             this.errore = "Messaggio da consegnare is Null (Msg)";
  323.             return false;
  324.         }
  325.         if(ServiceBinding.SOAP.equals(this.requestMsg.getServiceBinding())){
  326.             this.isSoap = true;
  327.         }
  328.         else{
  329.             this.isRest = true;
  330.         }
  331.         this.sbustamentoSoap = request.isSbustamentoSOAP();
  332.         this.propertiesTrasporto = request.getPropertiesTrasporto();
  333.         this.propertiesUrlBased = request.getPropertiesUrlBased();

  335.         // Credenziali
  336.         //this.tipoAutenticazione = request.getAutenticazione();
  337.         this.credenziali = request.getCredenziali();

  339.         // Identificativo modulo
  340.         this.idModulo = request.getIdModulo();
  341.         
  342.         // PolicyConfig
  343.         this.policyTimeoutConfig = request.getPolicyTimeoutConfig();
  344.                 
  345.         // Context per invocazioni handler
  346.         this.outRequestContext = request.getOutRequestContext();
  347.         this.msgDiagnostico = request.getMsgDiagnostico();

  349.         // Limit
  350.         if(this.getPddContext()!=null && this.getPddContext().containsKey(org.openspcoop2.core.constants.Costanti.LIMITED_STREAM)){
  351.             Object o = this.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.LIMITED_STREAM);
  352.             if(o!=null && o instanceof SogliaDimensioneMessaggio) {
  353.                 try {
  354.                     SogliaDimensioneMessaggio soglia = (SogliaDimensioneMessaggio) o;
  355.                     if(soglia!=null && soglia.getSogliaKb()>0) {
  356.                         this.useLimitedInputStream = true;
  357.                         this.limitBytes = soglia;
  358.                     }
  359.                 }catch(Throwable t) {
  360.                     // ignore
  361.                 }
  362.             }
  363.         }
  364.         
  365.         // Timeout, Dump
  366.         this.useTimeoutInputStream = this.openspcoopProperties.isConnettoriUseTimeoutInputStream();
  367.         boolean dumpBinario = this.debug;
  368.         DumpConfigurazione dumpConfigurazione = null;
  369.         String protocol = this.getProtocolFactory()!=null ? this.getProtocolFactory().getProtocol() : null;
  370.         IDSoggetto dominio = this.requestInfo!=null ? this.requestInfo.getIdentitaPdD() : this.openspcoopProperties.getIdentitaPortaDefault(protocol, this.requestInfo);
  371.         String nomePorta = (this.requestInfo!=null && this.requestInfo.getProtocolContext()!=null) ? this.requestInfo.getProtocolContext().getInterfaceName() : null;
  372.         if(this.policyTimeoutConfig!=null) {
  373.             // entro qua tramite la gestione dei token di validazione, negoziazione e attribute authority
  374.             try {
  375.                 ConfigurazionePdDManager configurazionePdDManager = ConfigurazionePdDManager.getInstance();
  376.                 if(this.pa!=null) {
  377.                     this.useTimeoutInputStream = configurazionePdDManager.isConnettoriUseTimeoutInputStream(this.pa);
  378.                     this.proprietaPorta = this.pa.getProprietaList();
  379.                 }
  380.                 else if(this.pd!=null) {
  381.                     this.useTimeoutInputStream = configurazionePdDManager.isConnettoriUseTimeoutInputStream(this.pd);
  382.                     this.proprietaPorta = this.pd.getProprietaList();
  383.                 }
  384.             }catch(Exception e){
  385.                 this.eccezioneProcessamento = e;
  386.                 this.logger.error("Errore durante l'inizializzazione della configurazione di timeout: "+this.readExceptionMessageFromException(e),e);
  387.                 this.errore = "Errore durante l'inizializzazione della configurazione di timeout: "+this.readExceptionMessageFromException(e);
  388.                 return false;
  389.             }
  390.         }
  391.         else if(this.idModulo!=null) {
  392.             try {
  393.                 // Soglia Dump
  394.                 this.dumpBinario_soglia = this.openspcoopProperties.getDumpBinarioInMemoryThreshold();
  395.                 this.dumpBinario_repositoryFile = this.openspcoopProperties.getDumpBinarioRepository();
  396.                 
  397.                 ConfigurazionePdDManager configurazionePdDManager = ConfigurazionePdDManager.getInstance();
  398.                 if(ConsegnaContenutiApplicativi.ID_MODULO.equals(this.idModulo)){
  399.                     
  400.                     IDPortaApplicativa idPA = null;
  401.                     if(request.getIdPortaApplicativa()!=null) {
  402.                         idPA = request.getIdPortaApplicativa();
  403.                     }
  404.                     else if(nomePorta!=null) {
  405.                         idPA = new IDPortaApplicativa();
  406.                         idPA.setNome(nomePorta);
  407.                     }
  408.                     
  409.                     ConfigurazioneTracciamento configurazioneTracciamento = new ConfigurazioneTracciamento(this.logger.getLogger(), configurazionePdDManager, TipoPdD.APPLICATIVA);
  410.                     this.logFileTrace_headers = configurazioneTracciamento.isTransazioniFileTraceDumpBinarioConnettoreHeaderEnabled();
  411.                     this.logFileTrace_payload = configurazioneTracciamento.isTransazioniFileTraceDumpBinarioConnettorePayloadEnabled();
  412.                     
  413.                     if(idPA!=null) {
  414.                         this.pa = configurazionePdDManager.getPortaApplicativaSafeMethod(idPA, this.requestInfo);
  415.                         if(this.pa!=null) {
  416.                             this.useTimeoutInputStream = configurazionePdDManager.isConnettoriUseTimeoutInputStream(this.pa);
  417.                             dumpConfigurazione = configurazionePdDManager.getDumpConfigurazione(this.pa);
  418.                             configurazioneTracciamento = new ConfigurazioneTracciamento(this.logger.getLogger(), configurazionePdDManager, this.pa);
  419.                             this.logFileTrace_headers = configurazioneTracciamento.isTransazioniFileTraceDumpBinarioConnettoreHeaderEnabled();
  420.                             this.logFileTrace_payload = configurazioneTracciamento.isTransazioniFileTraceDumpBinarioConnettorePayloadEnabled();
  421.                             this.proprietaPorta = this.pa.getProprietaList();
  422.                             if(request.getTransazioneApplicativoServer()!=null) {
  423.                                 this.nomeConnettoreAsincrono = request.getTransazioneApplicativoServer().getConnettoreNome();
  424.                             }
  425.                         }
  426.                     }
  427.                     
  428.                 }
  429.                 else {
  430.                     
  431.                     IDPortaDelegata idPD = null;
  432.                     if(nomePorta!=null) {
  433.                         idPD = new IDPortaDelegata();
  434.                         idPD.setNome(nomePorta);
  435.                     }
  436.                     
  437.                     ConfigurazioneTracciamento configurazioneTracciamento = new ConfigurazioneTracciamento(this.logger.getLogger(), configurazionePdDManager, TipoPdD.DELEGATA);
  438.                     this.logFileTrace_headers = configurazioneTracciamento.isTransazioniFileTraceDumpBinarioConnettoreHeaderEnabled();
  439.                     this.logFileTrace_payload = configurazioneTracciamento.isTransazioniFileTraceDumpBinarioConnettorePayloadEnabled();
  440.                     
  441.                     if(idPD!=null) {
  442.                         this.pd = configurazionePdDManager.getPortaDelegataSafeMethod(idPD, this.requestInfo);
  443.                         if(this.pd!=null) {
  444.                             this.useTimeoutInputStream = configurazionePdDManager.isConnettoriUseTimeoutInputStream(this.pd);
  445.                             dumpConfigurazione = configurazionePdDManager.getDumpConfigurazione(this.pd);
  446.                             configurazioneTracciamento = new ConfigurazioneTracciamento(this.logger.getLogger(), configurazionePdDManager, this.pd);
  447.                             this.logFileTrace_headers = configurazioneTracciamento.isTransazioniFileTraceDumpBinarioConnettoreHeaderEnabled();
  448.                             this.logFileTrace_payload = configurazioneTracciamento.isTransazioniFileTraceDumpBinarioConnettorePayloadEnabled();
  449.                             this.proprietaPorta = this.pd.getProprietaList();
  450.                         }
  451.                     }
  452.                     
  453.                 }
  454.             
  455.                 if(request.getTransazioneApplicativoServer()!=null) {
  456.                     this.logFileTrace_headers = false;
  457.                     this.logFileTrace_payload = false;
  458.                 }
  459.                 
  460.                 this.dumpRaw = new DumpRaw(this.logger,dominio,this.idModulo,this.outRequestContext.getTipoPorta(), 
  461.                         dumpBinario, 
  462.                         dumpConfigurazione,
  463.                         this.logFileTrace_headers, this.logFileTrace_payload);
  464.                 if(this.dumpRaw.isActiveDumpDatabase()) {
  465.                     if(request.getTransazioneApplicativoServer()!=null) {
  466.                         this.dumpRaw.initDump(nomePorta, this.outRequestContext.getPddContext(),
  467.                                 request.getTransazioneApplicativoServer(), 
  468.                                 request.getIdPortaApplicativa(), request.getDataConsegnaTransazioneApplicativoServer());
  469.                     }
  470.                     else {
  471.                         this.dumpRaw.initDump(nomePorta, this.outRequestContext.getPddContext());
  472.                     }
  473.                 }
  474.             }catch(Exception e){
  475.                 this.eccezioneProcessamento = e;
  476.                 this.logger.error("Errore durante l'inizializzazione del dump binario: "+this.readExceptionMessageFromException(e),e);
  477.                 this.errore = "Errore durante l'inizializzazione del dump binario: "+this.readExceptionMessageFromException(e);
  478.                 return false;
  479.             }
  480.         }
  481.         
  482.         // Diagnostic Input Stream
  483.         if(this.idModulo!=null && this.msgDiagnostico!=null) {
  484.             if(ConsegnaContenutiApplicativi.ID_MODULO.equals(this.idModulo)){
  485.                 this.useDiagnosticInputStream = this.openspcoopProperties.isConnettoriUseDiagnosticInputStream_consegnaContenutiApplicativi();
  486.             }
  487.             else {
  488.                 this.useDiagnosticInputStream = this.openspcoopProperties.isConnettoriUseDiagnosticInputStream_inoltroBuste();
  489.             }
  490.         }
  491.         
  492.         
  493.         // IdTransazione
  494.         if(this.getPddContext()!=null) {
  495.             Object oIdTransazione = this.getPddContext().getObject(Costanti.ID_TRANSAZIONE);
  496.             if(oIdTransazione!=null && (oIdTransazione instanceof String)){
  497.                 this.idTransazione = (String) oIdTransazione;
  498.             }
  499.         }
  500.         
  501.         // Cache Response
  502.         this.responseCachingConfig = responseCachingConfig;
  503.         if(this.responseCachingConfig!=null && StatoFunzionalita.ABILITATO.equals(this.responseCachingConfig.getStato())) {
  504.             if(this.requestMsg!=null) {
  505.                 Object digestO = this.requestMsg.getContextProperty(CostantiPdD.RESPONSE_CACHE_REQUEST_DIGEST);
  506.                 if(digestO!=null) {
  507.                     
  508.                     Transaction transactionNullable = null;
  509.                     try{
  510.                         if(this.idTransazione!=null) {
  511.                             transactionNullable = TransactionContext.getTransaction(this.idTransazione);
  512.                         }
  513.                     }catch(Throwable e){
  514.                         // La transazione potrebbe essere stata eliminata nelle comunicazioni stateful
  515.                     }
  516.                     
  517.                     if(transactionNullable!=null) {
  518.                         transactionNullable.getTempiElaborazione().startResponseCachingReadFromCache();
  519.                     }
  520.                     
  521.                     this.responseCachingDigest = (String) digestO;
  522.                     try{
  523.                         ResponseCached responseCached =  GestoreCacheResponseCaching.getInstance().readByDigest(this.responseCachingDigest);
  524.                         if(responseCached!=null) {
  525.                         
  526.                             // esiste una risposta cachata, verifico eventuali direttive
  527.                             ResponseCachingConfigurazioneControl cacheControl = this.responseCachingConfig.getControl();
  528.                             if(cacheControl==null) {
  529.                                 cacheControl = new ResponseCachingConfigurazioneControl(); // uso i valori di default
  530.                             }
  531.                             if(cacheControl!=null) {
  532.                         
  533.                                 Map<String, List<String>> trasportoRichiesta = null;
  534.                                 if(this.requestMsg!=null && this.requestMsg.getTransportRequestContext()!=null && 
  535.                                         this.requestMsg.getTransportRequestContext().getHeaders()!=null) {
  536.                                     trasportoRichiesta = this.requestMsg.getTransportRequestContext().getHeaders();
  537.                                 }
  538.                                 
  539.                                 if(cacheControl.isNoCache()) {
  540.                                     if(HttpUtilities.isDirectiveNoCache(trasportoRichiesta)) {
  541.                                         GestoreCacheResponseCaching.getInstance().removeByUUID(responseCached.getUuid());
  542.                                         responseCached = null;
  543.                                     }
  544.                                 }
  545.                                 
  546.                                 if(responseCached!=null) {
  547.                                     if(cacheControl.isMaxAge()) {
  548.                                         Integer maxAge = HttpUtilities.getDirectiveCacheMaxAge(trasportoRichiesta);
  549.                                         if(maxAge!=null && maxAge.intValue()>0) {
  550.                                             if(responseCached.getAgeInSeconds() > maxAge.intValue()) {
  551.                                                 GestoreCacheResponseCaching.getInstance().removeByUUID(responseCached.getUuid());
  552.                                                 responseCached = null;
  553.                                             }
  554.                                         }
  555.                                     }
  556.                                 }
  557.                                     
  558.                             }
  559.                             
  560.                             if(responseCached!=null) {
  561.                             
  562.                                 OpenSPCoop2Message msgResponse = responseCached.toOpenSPCoop2Message(
  563.                                         org.openspcoop2.pdd.core.Utilities.getOpenspcoop2MessageFactory(this.logger.getLogger(), this.requestMsg, this.requestInfo, MessageRole.RESPONSE),
  564.                                         this.openspcoopProperties.getAttachmentsProcessingMode(),
  565.                                         this.openspcoopProperties.getCachingResponseHeaderCacheKey());
  566.                                                         
  567.                                 this.responseMsg = msgResponse;
  568.                                 
  569.                                 this.dataAccettazioneRisposta = DateManager.getDate();
  570.                                 
  571.                                 org.openspcoop2.utils.transport.TransportResponseContext transportResponseContenxt = msgResponse.getTransportResponseContext();
  572.                                 
  573.                                 if(transportResponseContenxt!=null && transportResponseContenxt.getCodiceTrasporto()!=null){
  574.                                     try {
  575.                                         this.codice = Integer.parseInt(transportResponseContenxt.getCodiceTrasporto());
  576.                                     }catch(Exception e) {
  577.                                         this.logger.error("Errore durante la conversione del codice di trasporto ["+transportResponseContenxt.getCodiceTrasporto()+"]");
  578.                                         this.codice = 200;
  579.                                     }
  580.                                 }
  581.                                 else {
  582.                                     this.codice = 200;
  583.                                 }
  584.                                 
  585.                                 if(transportResponseContenxt!=null) {
  586.                                     this.propertiesTrasportoRisposta = transportResponseContenxt.getHeaders();
  587.                                 }
  588.                                 
  589.                                 this.contentLength = responseCached.getMessageLength();
  590.                                 
  591.                                 if(this.getPddContext()!=null) {
  592.                                     this.getPddContext().addObject(RESPONSE_FROM_CACHE, true);
  593.                                 }
  594.                                 
  595.                                 this.location = LOCATION_CACHED;
  596.                                 
  597.                                 
  598.                                 this.responseAlready = true;
  599.                                 
  600.                             }
  601.                         }
  602.                     }catch(Exception e){
  603.                         this.eccezioneProcessamento = e;
  604.                         this.logger.error("Errore durante la lettura della cache delle risposte: "+this.readExceptionMessageFromException(e),e);
  605.                         this.errore = "Errore durante la lettura della cache delle risposte: "+this.readExceptionMessageFromException(e);
  606.                         return false;
  607.                     }finally {
  608.                         if(transactionNullable!=null) {
  609.                             transactionNullable.getTempiElaborazione().endResponseCachingReadFromCache();
  610.                         }
  611.                     }
  612.                 }
  613.             }
  614.         }

  616.         // Negoziazione Token
  617.         this.policyNegoziazioneToken = request.getPolicyNegoziazioneToken();
  618.                 
  619.         // API
  620.         this.idAccordo = request.getIdAccordo();
  621.         
  622.         return true;
  623.     }
  624.     
  625.     private static final String format = "yyyy-MM-dd HH:mm:ss.SSS";
  626.     protected NameValue getTokenHeader() throws ConnettoreException {
  627.         return this.getTokenParameter(true);
  628.     }
  629.     protected NameValue getTokenQueryParameter() throws ConnettoreException {
  630.         return this.getTokenParameter(false);
  631.     }
  632.     private ModIValidazioneSemanticaProfiloSicurezza modIValidazioneSemanticaProfiloSicurezza;
  633.     public void setModIValidazioneSemanticaProfiloSicurezza(
  634.             ModIValidazioneSemanticaProfiloSicurezza modIValidazioneSemanticaProfiloSicurezza) {
  635.         this.modIValidazioneSemanticaProfiloSicurezza = modIValidazioneSemanticaProfiloSicurezza;
  636.     }
  637.     private NameValue getTokenParameter(boolean header) throws ConnettoreException {
  638.         if(this.policyNegoziazioneToken!=null) {
  639.             try {
  640.                 GestoreToken.validazioneConfigurazione(this.policyNegoziazioneToken); // assicura che la configurazione sia corretta
  641.                 
  642.                 String forwardMode = this.policyNegoziazioneToken.getForwardTokenMode();
  643.                 NameValue n = null;
  644.                 if(org.openspcoop2.pdd.core.token.Costanti.POLICY_RETRIEVE_TOKEN_FORWARD_MODE_RFC6750_HEADER.equals(forwardMode)) {
  645.                     if(header) {
  646.                         n = new NameValue();
  647.                         n.setName(HttpConstants.AUTHORIZATION);
  648.                         n.setValue(HttpConstants.AUTHORIZATION_PREFIX_BEARER);
  649.                     }
  650.                     else {
  651.                         return null;
  652.                     }
  653.                 }
  654.                 else if(org.openspcoop2.pdd.core.token.Costanti.POLICY_TOKEN_FORWARD_TRASPARENTE_MODE_RFC6750_URL.equals(forwardMode)) {
  655.                     if(!header) {
  656.                         n = new NameValue();
  657.                         n.setName(org.openspcoop2.pdd.core.token.Costanti.RFC6750_URI_QUERY_PARAMETER_ACCESS_TOKEN);
  658.                     }
  659.                     else {
  660.                         return null;
  661.                     }
  662.                 }
  663.                 else if(org.openspcoop2.pdd.core.token.Costanti.POLICY_TOKEN_FORWARD_TRASPARENTE_MODE_CUSTOM_HEADER.equals(forwardMode)) {
  664.                     if(header) {
  665.                         n = new NameValue();
  666.                         n.setName(this.policyNegoziazioneToken.getForwardTokenModeCustomHeader());
  667.                     }
  668.                     else {
  669.                         return null;
  670.                     }
  671.                 }
  672.                 else if(org.openspcoop2.pdd.core.token.Costanti.POLICY_TOKEN_FORWARD_TRASPARENTE_MODE_CUSTOM_URL.equals(forwardMode)) {
  673.                     if(!header) {
  674.                         n = new NameValue();
  675.                         n.setName(this.policyNegoziazioneToken.getForwardTokenModeCustomUrl());
  676.                     }
  677.                     else {
  678.                         return null;
  679.                     }
  680.                 }
  681.                 
  682.                 if(this.debug) {
  683.                     this.logger.debug("Negoziazione token '"+this.policyNegoziazioneToken.getName()+"' ...");
  684.                 }
  685.                 if(this.msgDiagnostico!=null) {
  686.                     try {
  687.                         this.msgDiagnostico.logPersonalizzato("negoziazioneToken.inCorso");
  688.                     }catch(Throwable t) {
  689.                         this.logger.error("Emissione diagnostica 'negoziazioneToken.inCorso' fallita: "+t.getMessage(),t);
  690.                     }
  691.                 }
  692.                 EsitoNegoziazioneToken esitoNegoziazione = GestoreToken.endpointToken(this.debug, this.logger.getLogger(), this.policyNegoziazioneToken, 
  693.                         this.busta, this.requestInfo, 
  694.                         ConsegnaContenutiApplicativi.ID_MODULO.equals(this.idModulo) ? TipoPdD.APPLICATIVA : TipoPdD.DELEGATA, this.idModulo, this.pa, this.pd,
  695.                         this.getPddContext(), this.getProtocolFactory());
  696.                 if(this.debug) {
  697.                     this.logger.debug("Negoziazione token '"+this.policyNegoziazioneToken.getName()+"' terminata");
  698.                 }
  699.                 
  700.                 SimpleDateFormat sdf = DateUtils.getDefaultDateTimeFormatter(format);
  701.                                 
  702.                 if(esitoNegoziazione==null) {
  703.                     throw new Exception("Esito Negoziazione non ritornato ?");
  704.                 }
  705.                 if(!esitoNegoziazione.isValido()) {
  706.                     throw new Exception(esitoNegoziazione.getDetails(),esitoNegoziazione.getEccezioneProcessamento());
  707.                 }
  708.                 if(esitoNegoziazione.isInCache()) {
  709.                     if(esitoNegoziazione.getInformazioniNegoziazioneToken().getExpiresIn()!=null) {
  710.                         this.logger.debug("Presente in cache access_token '"+esitoNegoziazione.getToken()+"'; expire in ("+sdf.format(esitoNegoziazione.getInformazioniNegoziazioneToken().getExpiresIn())+")");
  711.                     }
  712.                     else {
  713.                         this.logger.debug("Presente in cache access_token '"+esitoNegoziazione.getToken()+"'; no expire");
  714.                     }
  715.                     if(this.msgDiagnostico!=null) {
  716.                         try {
  717.                             this.msgDiagnostico.logPersonalizzato("negoziazioneToken.inCache");
  718.                         }catch(Exception t) {
  719.                             this.logger.error("Emissione diagnostica 'negoziazioneToken.inCache' fallita: "+t.getMessage(),t);
  720.                         }
  721.                     }
  722.                 }
  723.                 else {
  724.                     if(esitoNegoziazione.getInformazioniNegoziazioneToken().getExpiresIn()!=null) {
  725.                         this.logger.debug("Recuperato access_token '"+esitoNegoziazione.getToken()+"'; expire in ("+sdf.format(esitoNegoziazione.getInformazioniNegoziazioneToken().getExpiresIn())+")");
  726.                     }
  727.                     else {
  728.                         this.logger.debug("Recuperato access_token '"+esitoNegoziazione.getToken()+"'; no expire");
  729.                     }
  730.                     if(this.msgDiagnostico!=null) {
  731.                         try {
  732.                             this.msgDiagnostico.logPersonalizzato("negoziazioneToken.completata");
  733.                         }catch(Exception t) {
  734.                             this.logger.error("Emissione diagnostica 'negoziazioneToken.completata' fallita: "+t.getMessage(),t);
  735.                         }
  736.                     }
  737.                 }
  738.                 
  739.                 if(this.modIValidazioneSemanticaProfiloSicurezza!=null) {
  740.                     String jti = ModIUtils.readJti(esitoNegoziazione.getToken(), this.logger.getLogger());
  741.                     if(jti!=null && StringUtils.isNotEmpty(jti)) {
  742.                         ModIUtils.replaceBustaIdWithJtiTokenId(this.modIValidazioneSemanticaProfiloSicurezza, jti);
  743.                         if(this.msgDiagnostico!=null) {
  744.                             this.msgDiagnostico.updateKeywordIdMessaggioRichiesta(this.busta.getID());
  745.                         }
  746.                         if(this.getPddContext()!=null) {
  747.                             this.getPddContext().put(org.openspcoop2.core.constants.Costanti.MODI_JTI_REQUEST_ID, jti);
  748.                         }
  749.                     }
  750.                     
  751.                     if(this.msgDiagnostico!=null) {
  752.                         try {
  753.                             this.msgDiagnostico.logPersonalizzato("inoltroInCorso");
  754.                         }catch(Exception t) {
  755.                             this.logger.error("Emissione diagnostica 'inoltroInCorso' fallita: "+t.getMessage(),t);
  756.                         }
  757.                     }
  758.                 }
  759.                 
  760.                 if(n.getValue()!=null) {
  761.                     n.setValue(n.getValue()+esitoNegoziazione.getToken());
  762.                 }
  763.                 else {
  764.                     n.setValue(esitoNegoziazione.getToken());
  765.                 }
  766.                 return n;

  768.             }catch(Exception e) {
  769.                 if(this.getPddContext()!=null) {
  770.                     this.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.ERRORE_NEGOZIAZIONE_TOKEN, "true");
  771.                 }
  772.                 throw new ConnettoreException(e.getMessage(),e);
  773.             }
  774.         }
  775.         
  776.         return null;
  777.     }
  778.     
  779.     private void saveResponseInCache() {
  780.         
  781.         Transaction transactionNullable = null;
  782.         try{
  783.             if(this.getPddContext()!=null) {
  784.                 Object oIdTransazione = this.getPddContext().getObject(Costanti.ID_TRANSAZIONE);
  785.                 String idTransazione = null;
  786.                 if(oIdTransazione!=null && (oIdTransazione instanceof String)){
  787.                     idTransazione = (String) oIdTransazione;
  788.                 }
  789.                 transactionNullable = TransactionContext.getTransaction(idTransazione);
  790.             }
  791.         }catch(Throwable e){
  792.             // La transazione potrebbe essere stata eliminata nelle comunicazioni stateful
  793.         }
  794.         
  795.         if(transactionNullable!=null) {
  796.             transactionNullable.getTempiElaborazione().startResponseCachingSaveInCache();
  797.         }
  798.         
  799.         try {
  800.             if(this.responseCachingConfig!=null && StatoFunzionalita.ABILITATO.equals(this.responseCachingConfig.getStato()) &&
  801.                     this.responseMsg!=null) { // jms, null ha la response null
  802.                 
  803.                 boolean saveInCache = true;
  804.                 
  805.                 int cacheTimeoutSeconds = this.responseCachingConfig.getCacheTimeoutSeconds().intValue();
  806.                 
  807.                 Long kbMax = this.responseCachingConfig.getMaxMessageSize();
  808.                 long byteMax = -1;
  809.                 if(kbMax!=null) {
  810.                     byteMax = kbMax.longValue() * 1024;
  811.                 }
  812.                 
  813.                 Map<String, List<String>> trasportoRichiesta = null;
  814.                 if(this.requestMsg!=null && this.requestMsg.getTransportRequestContext()!=null && 
  815.                         this.requestMsg.getTransportRequestContext().getHeaders()!=null) {
  816.                     trasportoRichiesta = this.requestMsg.getTransportRequestContext().getHeaders();
  817.                 }
  818.                 
  819.                 ResponseCachingConfigurazioneControl cacheControl = this.responseCachingConfig.getControl();
  820.                 if(cacheControl==null) {
  821.                     cacheControl = new ResponseCachingConfigurazioneControl(); // uso i valori di default
  822.                 }
  823.                 if(cacheControl!=null) {
  824.                     if(cacheControl.isNoStore()) {
  825.                         if(HttpUtilities.isDirectiveNoStore(trasportoRichiesta)) {
  826.                             saveInCache = false;
  827.                         }
  828.                     }
  829.                 }
  830.                 
  831.                 if(saveInCache) {
  832.                     if(this.responseCachingConfig.sizeRegolaList()>0) {
  833.                         
  834.                         int returnCode = -1;
  835.                         try {
  836.                             if(this.responseMsg.getTransportResponseContext()!=null && this.responseMsg.getTransportResponseContext().getCodiceTrasporto()!=null) {
  837.                                 returnCode = Integer.parseInt(this.responseMsg.getTransportResponseContext().getCodiceTrasporto());
  838.                             }
  839.                         }catch(Exception e) {}
  840.                         
  841.                         boolean isFault = this.responseMsg.isFault();
  842.                         
  843.                         ResponseCachingConfigurazioneRegola regolaGeneraleIncludeFault = null;
  844.                         
  845.                         saveInCache = false; // se ci sono delle regole, salvo solamente se la regola ha un match
  846.                         for (ResponseCachingConfigurazioneRegola regola : this.responseCachingConfig.getRegolaList()) {
  847.                             
  848.                             if(returnCode>0 && regola.getReturnCodeMin()!=null) {
  849.                                 if(returnCode<regola.getReturnCodeMin().intValue()) {
  850.                                     continue;
  851.                                 }
  852.                             }
  853.                             if(returnCode>0 && regola.getReturnCodeMax()!=null) {
  854.                                 if(returnCode>regola.getReturnCodeMax().intValue()) {
  855.                                     continue;
  856.                                 }
  857.                             }
  858.                             
  859.                             if(isFault && !regola.isFault()) {
  860.                                 continue;
  861.                             }
  862.                             else if(!isFault && regola.isFault()) {
  863.                                 // in questo caso la regola va bene poichè l'istruzione fault indica semplicemente se includere o meno un fault
  864.                                 // e quindi essendo il messaggio non un fault la regola match.
  865.                                 // Però prima di usarla verifico se esiste una regola specifica senza fault
  866.                                 if(regolaGeneraleIncludeFault==null) {
  867.                                     regolaGeneraleIncludeFault = regola;
  868.                                 }
  869.                                 continue;
  870.                             }
  871.                             
  872.                             // ho un match
  873.                             saveInCache = true;
  874.                             if(regola.getCacheTimeoutSeconds()!=null) {
  875.                                 cacheTimeoutSeconds = regola.getCacheTimeoutSeconds().intValue();
  876.                             }
  877.                             break;
  878.                         }
  879.                         
  880.                         if(!saveInCache && regolaGeneraleIncludeFault!=null) {
  881.                             // ho il match di un messaggio che non è un fault con una regola che fa includere anche i fault
  882.                             saveInCache = true;
  883.                             if(regolaGeneraleIncludeFault.getCacheTimeoutSeconds()!=null) {
  884.                                 cacheTimeoutSeconds = regolaGeneraleIncludeFault.getCacheTimeoutSeconds().intValue();
  885.                             }
  886.                         }
  887.                     }
  888.                 }
  889.                 
  890.                 if(saveInCache) {               
  891.                     if(kbMax!=null) {
  892.                         if(this.contentLength>0) {
  893.                             if(this.contentLength>byteMax) {
  894.                                 this.logger.debug("Messaggio non salvato in cache, nonostante la configurazione lo richiesta poichè la sua dimensione ("+this.contentLength+ 
  895.                                         " bytes) supera la dimensione massima consentita ("+byteMax+" bytes)");
  896.                                 saveInCache = false;
  897.                             }
  898.                         }
  899.                     }
  900.                 }
  901.                 
  902.                 if(saveInCache) {
  903.                     ResponseCached responseCached = ResponseCached.toResponseCached(this.responseMsg, cacheTimeoutSeconds);
  904.                     if(kbMax!=null && this.contentLength<=0) {
  905.                         // ricontrollo poichè non era disponibile l'informazione
  906.                         if(responseCached.getMessageLength()>byteMax) {
  907.                             this.logger.debug("Messaggio non salvato in cache, nonostante la configurazione lo richiesta poichè la sua dimensione ("+responseCached.getMessageLength()+ 
  908.                                     " bytes) supera la dimensione massima consentita ("+byteMax+" bytes)");
  909.                             saveInCache = false;
  910.                         }
  911.                     }
  912.                     if(saveInCache) {
  913.                         GestoreCacheResponseCaching.getInstance().save(this.responseCachingDigest, responseCached);
  914.                     }
  915.                 }
  916.             }
  917.         }catch(Throwable e){
  918.             this.logger.error("Errore durante il salvataggio nella cache delle risposte: "+this.readExceptionMessageFromException(e),e);
  919.         }finally {
  920.             if(transactionNullable!=null) {
  921.                 transactionNullable.getTempiElaborazione().endResponseCachingSaveInCache();
  922.             }
  923.         }
  924.     }
  925.     
  926.     protected abstract boolean initializePreSend(ResponseCachingConfigurazione responseCachingConfig, ConnettoreMsg request);
  927.     
  928.     protected abstract boolean send(ConnettoreMsg request);
  929.     
  930.     @Override
  931.     public boolean send(ResponseCachingConfigurazione responseCachingConfig, ConnettoreMsg request){
  932.         
  933.         if(this.initializePreSend(responseCachingConfig, request)==false){
  934.             return false;
  935.         }
  936.         
  937.         // caching response
  938.         if(this.responseAlready) {
  939.             return true;
  940.         }
  941.         
  942.         boolean returnEsitoSend = send(request);
  943.         if(returnEsitoSend) {
  944.             saveResponseInCache();
  945.         }
  946.         return returnEsitoSend;
  947.     }
  948.     
  949.     /**
  950.      * In caso di avvenuto errore in fase di consegna, questo metodo ritorna il motivo dell'errore.
  951.      *
  952.      * @return motivo dell'errore (se avvenuto in fase di consegna).
  953.      * 
  954.      */
  955.     @Override
  956.     public String getErrore(){
  957.         return this.errore;
  958.     }

  960.     /**
  961.      * In caso di avvenuta consegna, questo metodo ritorna il codice di trasporto della consegna.
  962.      *
  963.      * @return se avvenuta una consegna ritorna il codice di trasporto della consegna.
  964.      * 
  965.      */
  966.     @Override
  967.     public int getCodiceTrasporto(){
  968.         return this.codice;
  969.     }

  971.     /**
  972.      * In caso di avvenuta consegna, questo metodo ritorna l'header del trasporto
  973.      *
  974.      * @return se avvenuta una consegna ritorna l'header del trasporto
  975.      * 
  976.      */
  977.     @Override
  978.     public Map<String, List<String>> getHeaderTrasporto(){
  979.         if(this.propertiesTrasportoRisposta.size()<=0){
  980.             return null;
  981.         }else{
  982.             return this.propertiesTrasportoRisposta;
  983.         }
  984.     }
  985.     
  986.     /**
  987.      * Ritorna la risposta pervenuta in seguita alla consegna effettuata
  988.      *
  989.      * @return la risposta.
  990.      * 
  991.      */
  992.     @Override
  993.     public OpenSPCoop2Message getResponse(){
  994.         if(this.responseMsg!=null) {
  995.             if(this.getProtocolFactory()!=null) {
  996.                 this.responseMsg.setProtocolName(this.getProtocolFactory().getProtocol());
  997.             }
  998.             if(this.getPddContext()!=null) {
  999.                 this.responseMsg.setTransactionId(PdDContext.getValue(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE, this.getPddContext()));
  1000.             }
  1001.         }
  1002.         return this.responseMsg;
  1003.     }

  1005.     /**
  1006.      * In caso di avvenuta consegna, questo metodo ritorna, se disponibile, la dimensione della risposta (-1 se non disponibile)
  1007.      *
  1008.      * @return se avvenuta una consegna,  questo metodo ritorna, se disponibile, la dimensione della risposta (-1 se non disponibile)
  1009.      * 
  1010.      */
  1011.     @Override
  1012.     public long getContentLength() {
  1013.         return this.contentLength;
  1014.     }
  1015.     
  1016.     /**
  1017.      * Ritorna l'informazione su dove il connettore sta spedendo il messaggio
  1018.      * 
  1019.      * @return location di inoltro del messaggio
  1020.      */
  1021.     @Override
  1022.     public String getLocation() throws ConnettoreException{
  1023.         return this.location;
  1024.     }
  1025.     
  1026.     /**
  1027.      * Ritorna l'eccezione in caso di errore di processamento
  1028.      * 
  1029.      * @return eccezione in caso di errore di processamento
  1030.      */
  1031.     @Override
  1032.     public Exception getEccezioneProcessamento(){
  1033.         return this.eccezioneProcessamento;
  1034.     }
  1035.     
  1036.     /**
  1037.      * Effettua la disconnessione 
  1038.      */
  1039.     @Override
  1040.     public void disconnect() throws ConnettoreException{
  1041.         
  1042.         try{
  1043.         
  1044.             // Rilascio eventuali risorse associate al messaggio di risposte 
  1045.             // Tali risorse non sono ancora rilasciate, se durante il flusso e' stato generato un nuovo messaggio.
  1046.             // Due chiamate della close non provocano problemi, la seconda non comporta nessun effetto essendo lo stream 'NotifierInputStream' gia' chiuso
  1047.             if(this.responseMsg!=null && this.responseMsg.getNotifierInputStream()!=null){
  1048.                 this.responseMsg.getNotifierInputStream().close();
  1049.             }
  1050.             
  1051.         }catch(Exception e){
  1052.             throw new ConnettoreException("Chiusura connessione non riuscita: "+e.getMessage(),e);
  1053.         }
  1054.         
  1055.     }
  1056.     
  1057.     /**
  1058.      * Data di creazione del connettore 
  1059.      */
  1060.     @Override
  1061.     public Date getCreationDate() throws ConnettoreException{
  1062.         return this.creationDate;
  1063.     }
  1064.     
  1065.     
  1066.     /**
  1067.      * Ritorna le opzioni di NotifierInputStreamParams per la risposta
  1068.      * 
  1069.      * @return NotifierInputStreamParams
  1070.      * @throws ConnettoreException
  1071.      */
  1072.     @Override
  1073.     public NotifierInputStreamParams getNotifierInputStreamParamsResponse() throws ConnettoreException{
  1074.         if(this.preInResponseContext !=null){
  1075.             return this.preInResponseContext.getNotifierInputStreamParams();
  1076.         }
  1077.         return null;
  1078.     }
  1079.     
  1080.     
  1081.     protected void postOutRequest() throws Exception{
  1082.         
  1083.         if(this.registerSendIntoContext && this.getPddContext()!=null) {
  1084.             this.getPddContext().addObject(Costanti.RICHIESTA_INOLTRATA_BACKEND, Costanti.RICHIESTA_INOLTRATA_BACKEND_VALORE);
  1085.         }
  1086.        
  1087.         if(this.msgDiagnostico!=null && this.outRequestContext!=null){
  1088.             
  1089.             this.postOutRequestContext = new PostOutRequestContext(this.outRequestContext);
  1090.             this.postOutRequestContext.setCodiceTrasporto(this.getCodiceTrasporto());
  1091.             this.postOutRequestContext.setResponseHeaders(this.getHeaderTrasporto());
  1092.             
  1093.             // invocazione handler
  1094.             try{
  1095.                 GestoreHandlers.postOutRequest(this.postOutRequestContext, this.msgDiagnostico, OpenSPCoop2Logger.getLoggerOpenSPCoopCore());
  1096.             }catch(Exception e){
  1097.                 if(e instanceof HandlerException){
  1098.                     HandlerException he = (HandlerException) e;
  1099.                     if(he.isEmettiDiagnostico()){
  1100.                         this.msgDiagnostico.logErroreGenerico(e, ((HandlerException)e).getIdentitaHandler());
  1101.                     }
  1102.                     else{
  1103.                         OpenSPCoop2Logger.getLoggerOpenSPCoopCore().error(e.getMessage(),e);
  1104.                     }
  1105.                 }else{
  1106.                     this.msgDiagnostico.logErroreGenerico(e, "PostOutRequestHandler");
  1107.                 }
  1108.                 throw e;
  1109.             }
  1110.         }
  1111.         
  1112.     }
  1113.     
  1114.     protected void preInResponse() throws Exception{
  1115.         
  1116.         this.dataAccettazioneRisposta = DateManager.getDate();
  1117.         
  1118.         if(this.msgDiagnostico!=null && this.outRequestContext!=null){
  1119.         
  1120.             PostOutRequestContext postContext = this.postOutRequestContext;
  1121.             if(postContext==null){
  1122.                 postContext = new PostOutRequestContext(this.outRequestContext);
  1123.                 postContext.setCodiceTrasporto(this.getCodiceTrasporto());
  1124.                 postContext.setResponseHeaders(this.getHeaderTrasporto());
  1125.             }
  1126.             
  1127.             this.preInResponseContext = new PreInResponseContext(postContext);
  1128.             
  1129.             // invocazione handler
  1130.             try{
  1131.                 GestoreHandlers.preInResponse(this.preInResponseContext, this.msgDiagnostico, OpenSPCoop2Logger.getLoggerOpenSPCoopCore());
  1132.             }catch(Exception e){
  1133.                 if(e instanceof HandlerException){
  1134.                     HandlerException he = (HandlerException) e;
  1135.                     if(he.isEmettiDiagnostico()){
  1136.                         this.msgDiagnostico.logErroreGenerico(e, ((HandlerException)e).getIdentitaHandler());
  1137.                     }
  1138.                     else{
  1139.                         OpenSPCoop2Logger.getLoggerOpenSPCoopCore().error(e.getMessage(),e);
  1140.                     }
  1141.                 }else{
  1142.                     this.msgDiagnostico.logErroreGenerico(e, "PreInResponseHandler");
  1143.                 }
  1144.                 throw e;
  1145.             }
  1146.         }
  1147.             
  1148.     }
  1149.         
  1150.     protected String readExceptionMessageFromException(Throwable e) {
  1151.         return readConnectionExceptionMessageFromException(e);
  1152.     }
  1153.     public static String readConnectionExceptionMessageFromException(Throwable e) {
  1154.         
  1155.         // In questo metodo è possibile gestire meglio la casistica dei messaggi di errore ritornati.
  1156.         
  1157.         // 1. Host Unknown
  1158.         // java.net.UnknownHostException
  1159.         if(e instanceof java.net.UnknownHostException){
  1160.             return "unknown host '"+e.getMessage()+"'";
  1161.         }
  1162.         
  1163.         // 2. java.net.SocketException
  1164.         if(e instanceof java.net.SocketException){
  1165.             java.net.SocketException s = (java.net.SocketException) e;
  1166.             if(_isNotNullMessageException(s)){
  1167.                 return s.getMessage();
  1168.             }
  1169.         }
  1170.         if(Utilities.existsInnerException(e, java.net.SocketException.class)){
  1171.             Throwable internal = Utilities.getInnerException(e, java.net.SocketException.class);
  1172.             if(_isNotNullMessageException(internal)){
  1173.                 return _buildException(e, internal);
  1174.             }
  1175.         }
  1176.         
  1177.         // 3. java.security.cert.CertificateException
  1178.         if(java.security.cert.CertificateException.class.isInstance(e)){
  1179.             java.security.cert.CertificateException ce = (java.security.cert.CertificateException) e;
  1180.             if(_isNotNullMessageException(ce)){
  1181.                 return ce.getMessage();
  1182.             }
  1183.         }
  1184.         if(Utilities.existsInnerInstanceException(e, java.security.cert.CertificateException.class)){
  1185.             boolean last = true;
  1186.             
  1187.             Throwable internalNotYetValid = Utilities.getInnerInstanceException(e, java.security.cert.CertificateNotYetValidException.class, last);
  1188.             if(internalNotYetValid!=null) {
  1189.                 if(_isNotNullMessageException(internalNotYetValid)){
  1190.                     return _buildException(e, internalNotYetValid);
  1191.                 }
  1192.             }
  1193.             
  1194.             Throwable internalExpired = Utilities.getInnerInstanceException(e, java.security.cert.CertificateExpiredException.class, last);
  1195.             if(internalExpired!=null) {
  1196.                 if(_isNotNullMessageException(internalExpired)){
  1197.                     return _buildException(e, internalExpired);
  1198.                 }
  1199.             }
  1200.             
  1201.             // Anche in questo caso vengono due eccezioni uguali
  1202. //          Throwable internalRevoked = Utilities.getInnerInstanceException(e, java.security.cert.CertificateRevokedException.class, last);
  1203. //          if(internalRevoked!=null) {
  1204. //              if(_isNotNullMessageException(internalRevoked)){
  1205. //                  return _buildException(e, internalRevoked);
  1206. //              }
  1207. //          }
  1208. //          
  1209.             // solo nei casi precedenti costruisco una eccezione con la parte interna.
  1210.             // Negli altri casi (es. certificato non presente nel truststore 'unable to find valid certification path to requested target') verrebbero due eccezioni uguali
  1211.             if(_isNotNullMessageException(e)){
  1212.                 return e.getMessage();
  1213.             }
  1214.         }
  1215.         
  1216.         // 4. java.io.IOException
  1217.         if(e instanceof java.io.IOException || java.io.IOException.class.isInstance(e)){
  1218.             java.io.IOException io = (java.io.IOException) e;
  1219.             if(_isNotNullMessageException(io)){
  1220.                 return io.getMessage();
  1221.             }
  1222.         }
  1223.         if(Utilities.existsInnerException(e, java.io.IOException.class)){
  1224.             Throwable internal = Utilities.getInnerException(e, java.io.IOException.class);
  1225.             if(_isNotNullMessageException(internal)){
  1226.                 return _buildException(e, internal);
  1227.             }
  1228.         }
  1229.         
  1230.         // 5. ClientAbortException (Succede nel caso il buffer del client non sia più disponibile)
  1231.         if(Utilities.existsInnerException(e, "org.apache.catalina.connector.ClientAbortException")){
  1232.             Throwable internal = Utilities.getInnerException(e, "org.apache.catalina.connector.ClientAbortException");
  1233.             if(_isNotNullMessageException(internal)){
  1234.                 return "ClientAbortException - "+ _buildException(e, internal);
  1235.             }
  1236.         }
  1237.                                 
  1238.         // Check Null Message
  1239.         if(_isNotNullMessageException(e)){
  1240.             return e.getMessage();
  1241.         }
  1242.         else{
  1243.             Throwable tNotEmpty = ParseExceptionUtils.getInnerNotEmptyMessageException(e);
  1244.             if(tNotEmpty!=null){
  1245.                 return tNotEmpty.getMessage();
  1246.             }
  1247.             else{
  1248.                 return "ErrorOccurs - "+ e.getMessage();
  1249.             }
  1250.         }
  1251.         
  1252.     }
  1253.     protected String buildException(Throwable original,Throwable internal){
  1254.         return _buildException(original, internal);
  1255.     }
  1256.     private static String _buildException(Throwable original,Throwable internal){
  1257.         if(_isNotNullMessageException(original)){
  1258.             String internalMessage = internal.getMessage();
  1259.             String originalMessage = original.getMessage();
  1260.             if(originalMessage!=null && !originalMessage.equals(internalMessage)) {
  1261.                 return internalMessage + " (sourceException: "+originalMessage+")";
  1262.             }
  1263.             else {
  1264.                 return internal.getMessage();
  1265.             }
  1266.         }
  1267.         else{
  1268.             return internal.getMessage();
  1269.         }
  1270.     }
  1271.     protected boolean isNotNullMessageException(Throwable tmp){
  1272.         return _isNotNullMessageException(tmp);
  1273.     }
  1274.     private static boolean _isNotNullMessageException(Throwable tmp){
  1275.         return tmp.getMessage()!=null && !"".equals(tmp.getMessage()) && !"null".equalsIgnoreCase(tmp.getMessage());
  1276.     }
  1277.     
  1278.     protected boolean isDumpBinarioRichiesta() {
  1279.         return this.debug || (this.dumpRaw!=null && this.dumpRaw.isActiveDumpDatabaseRichiesta()); 
  1280.                 //this.logFileTrace;
  1281.     }
  1282.     protected boolean isDumpBinarioRisposta() {
  1283.         return this.debug || (this.dumpRaw!=null && this.dumpRaw.isActiveDumpDatabaseRisposta()); 
  1284.                 //this.logFileTrace;
  1285.     }
  1286.     
  1287.     private InfoConnettoreUscita infoConnettoreUscita = null;
  1288.     protected void emitDiagnosticStartDumpBinarioRichiestaUscita() {
  1289.         if(this.dumpRaw!=null && this.dumpRaw.isActiveDumpDatabaseRichiesta()) {
  1290.             this.dumpRaw.emitDiagnosticStartDumpBinarioRichiestaUscita();
  1291.         }
  1292.     }
  1293.     protected void dumpBinarioRichiestaUscita(DumpByteArrayOutputStream bout, MessageType messageType, String contentTypeRichiesta,String location, Map<String, List<String>> trasporto) throws DumpException {
  1294.         if(this.debug){
  1295.             String content = null;
  1296.             if(bout!=null) {
  1297.                 content = bout.toString();
  1298.                 this.logger.info("Messaggio inviato (ContentType:"+contentTypeRichiesta+") :\n"+content,false);
  1299.             }
  1300.             else {
  1301.                 this.logger.info("Messaggio inviato senza contenuto nell'http-payload", false);
  1302.             }
  1303.         }
  1304.         if(this.dumpRaw!=null && this.dumpRaw.isActiveDumpDatabaseRichiesta()) {
  1305.             this.infoConnettoreUscita = new InfoConnettoreUscita();
  1306.             this.infoConnettoreUscita.setLocation(location);
  1307.             this.infoConnettoreUscita.setHeaders(trasporto);
  1308.             this.dumpRaw.dumpRequest(bout, messageType, this.infoConnettoreUscita);
  1309.         }
  1310.     }
  1311.     protected void emitDiagnosticStartDumpBinarioRispostaIngresso() {
  1312.         if(this.dumpRaw!=null && this.dumpRaw.isActiveDumpDatabaseRisposta()) {
  1313.             this.dumpRaw.emitDiagnosticStartDumpBinarioRispostaIngresso();
  1314.         }
  1315.     }
  1316.     protected void dumpBinarioRispostaIngresso(DumpByteArrayOutputStream raw, MessageType messageType, Map<String, List<String>> trasportoRisposta) throws DumpException {
  1317.         if(this.dumpRaw!=null && this.dumpRaw.isActiveDumpDatabaseRisposta()) {
  1318.             this.dumpRaw.dumpResponse(raw, messageType, this.infoConnettoreUscita, trasportoRisposta);
  1319.         }
  1320.     }
  1321.     
  1322.     protected Map<String, Object> dynamicMap = null;
  1323.     protected Map<String, Object> buildDynamicMap(ConnettoreMsg connettoreMsg){
  1324.         if(this.dynamicMap==null) {
  1325.             this.dynamicMap = new HashMap<>();
  1326.         }
  1327.         DynamicInfo dInfo = new DynamicInfo(connettoreMsg, this.getPddContext());
  1328.         Logger log = null;
  1329.         if(this.logger!=null) {
  1330.             log = this.logger.getLogger();
  1331.         }
  1332.         if(log==null) {
  1333.             log = OpenSPCoop2Logger.getLoggerOpenSPCoopCore();
  1334.         }
  1335.         DynamicUtils.fillDynamicMap(log,this.dynamicMap, dInfo);
  1336.         return this.dynamicMap;
  1337.     }
  1338.     
  1339.     protected String getDynamicProperty(String tipoConnettore,boolean required,String name,Map<String,Object> dynamicMap) throws ConnettoreException{
  1340.         String tmp = this.properties.get(name);
  1341.         if(tmp!=null){
  1342.             tmp = tmp.trim();
  1343.         }
  1344.         if(tmp==null || "".equals(tmp)){
  1345.             if(required){
  1346.                 throw new ConnettoreException("Proprieta' '"+name+"' non fornita e richiesta da questo tipo di connettore ["+tipoConnettore+"]");
  1347.             }
  1348.             return null;
  1349.         }
  1350.         try {
  1351.             return DynamicUtils.convertDynamicPropertyValue(name, tmp, dynamicMap, this.getPddContext(), false);
  1352.         }catch(Exception e) {
  1353.             throw new ConnettoreException(e.getMessage(),e);
  1354.         }
  1355.     }
  1356.     
  1357.    
  1358.     
  1359.     protected boolean isBooleanProperty(String tipoConnettore,boolean defaultValue,String name){
  1360.         String tmp = this.properties.get(name);
  1361.         if(tmp!=null){
  1362.             tmp = tmp.trim();
  1363.         }
  1364.         if(tmp==null || "".equals(tmp)){
  1365.             return defaultValue;
  1366.         }
  1367.         return "true".equalsIgnoreCase(tmp) || CostantiConfigurazione.ABILITATO.getValue().equalsIgnoreCase(tmp);
  1368.     }
  1369.     
  1370.     protected Integer getIntegerProperty(String tipoConnettore,boolean required,String name) throws ConnettoreException{
  1371.         String tmp = this.properties.get(name);
  1372.         if(tmp!=null){
  1373.             tmp = tmp.trim();
  1374.         }
  1375.         if(tmp==null || "".equals(tmp)){
  1376.             if(required){
  1377.                 throw new ConnettoreException("Proprieta' '"+name+"' non fornita e richiesta da questo tipo di connettore ["+tipoConnettore+"]");
  1378.             }
  1379.             return null;
  1380.         }
  1381.         try{
  1382.             return Integer.parseInt(tmp);
  1383.         }catch(Exception e){
  1384.             throw new ConnettoreException("Proprieta' '"+name+"' contiene un valore non corretto: "+e.getMessage(),e);
  1385.         }

  1387.     }
  1388.     
  1389.     
  1390.     protected void forwardHttpRequestHeader() throws Exception{
  1391.         OpenSPCoop2MessageProperties forwardHeader = null;
  1392.         if(ServiceBinding.REST.equals(this.requestMsg.getServiceBinding())) {
  1393.             forwardHeader = this.requestMsg.getForwardTransportHeader(this.openspcoopProperties.getRESTServicesHeadersForwardConfig(true));
  1394.         }
  1395.         else {
  1396.             forwardHeader = this.requestMsg.getForwardTransportHeader(this.openspcoopProperties.getSOAPServicesHeadersForwardConfig(true));
  1397.         }
  1398.                 
  1399.         if(forwardHeader!=null && forwardHeader.size()>0){
  1400.             if(this.debug)
  1401.                 this.logger.debug("Forward header di trasporto (size:"+forwardHeader.size()+") ...");
  1402.             if(this.propertiesTrasporto==null){
  1403.                 this.propertiesTrasporto = new HashMap<>();
  1404.             }
  1405.             Iterator<String> keys = forwardHeader.getKeys();
  1406.             while (keys.hasNext()) {
  1407.                 String key = (String) keys.next();
  1408.                 List<String> values = forwardHeader.getPropertyValues(key);
  1409.                 if(values!=null && !values.isEmpty()) {
  1410.                     List<String> vs = new ArrayList<>(values); // per evitare che la add sottostante aggiunga alla collezione e si continui a iterare
  1411.                     for (String value : vs) {
  1412.                         if(this.debug)
  1413.                             this.logger.debug("Forward Transport Header ["+key+"]=["+value+"]");
  1414.                         TransportUtils.addHeader(this.propertiesTrasporto, key, value);     
  1415.                     }
  1416.                 }
  1417.             }
  1418.         }
  1419.     }
  1420.     
  1421.     
  1422.     private Map<String,List<String>> headersImpostati = new HashMap<>(); // per evitare che header generati nel conettore siano sovrascritti da eventuali forward. Gli header del connettore vengono impostati prima del forward.
  1423.     protected void clearRequestHeader() {
  1424.         this.headersImpostati.clear();
  1425.     }
  1426.     private Messaggio messaggioDumpUscita = null;
  1427.     protected void setRequestHeader(String key,List<String> values) throws Exception {} // ridefinito nei connettori dove esistono header da spedire 
  1428.     protected void setRequestHeader(String key, String value, Map<String, List<String>> propertiesTrasportoDebug) throws Exception {
  1429.         List<String> list = new ArrayList<>(); 
  1430.         list.add(value);
  1431.         this.setRequestHeader(key, list, propertiesTrasportoDebug);
  1432.     }
  1433.     protected void setRequestHeader(String key,List<String> values, Map<String, List<String>> propertiesTrasportoDebug) throws Exception {
  1434.         if(!this.headersImpostati.containsKey(key)) {
  1435.             this.headersImpostati.put(key,values);
  1436.             this.setRequestHeader(key,values);
  1437.             if(propertiesTrasportoDebug!=null) {
  1438.                 propertiesTrasportoDebug.put(key, values);
  1439.             }
  1440.         }
  1441.         else {
  1442.             // Update eventuale dump in TransazioneContext
  1443.             if(this.messaggioDumpUscita==null) {
  1444.                 if(this.openspcoopProperties.isTransazioniSaveDumpInUniqueTransaction() && this.getPddContext()!=null && this.getPddContext().containsKey(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE)) {
  1445.                     try {
  1446.                         Transaction tr = TransactionContext.getTransaction((String)this.getPddContext().getObject(org.openspcoop2.core.constants.Costanti.ID_TRANSAZIONE));
  1447.                         if(tr!=null) {
  1448.                             for (Messaggio messaggio : tr.getMessaggi()) {
  1449.                                 if(TipoMessaggio.RICHIESTA_USCITA.equals(messaggio.getTipoMessaggio())) {
  1450.                                     this.messaggioDumpUscita = messaggio;
  1451.                                     break;
  1452.                                 }
  1453.                             }
  1454.                         }
  1455.                     }
  1456.                     catch(TransactionNotExistsException e) {
  1457.                         this.logger.debug("Adeguamento dump http header non riuscito (token ): "+e.getMessage());
  1458.                     }
  1459.                     catch(Throwable e){
  1460.                         this.logger.error("Adeguamento dump http header non riuscito: "+e.getMessage(),e);
  1461.                     }
  1462.                 }
  1463.             }
  1464.             if(this.messaggioDumpUscita!=null) {
  1465.                 if(this.messaggioDumpUscita.getHeaders()==null) {
  1466.                     this.messaggioDumpUscita.setHeaders(new HashMap<>());
  1467.                 }
  1468.                 TransportUtils.removeRawObject(this.messaggioDumpUscita.getHeaders(), key);
  1469.                 this.messaggioDumpUscita.getHeaders().put(key, this.headersImpostati.get(key));
  1470.             }
  1471.         }
  1472.     }
  1473.     
  1474.     private boolean emitDiagnosticResponseRead = false;
  1475.     protected void emitDiagnosticResponseRead(InputStream is) {
  1476.         if(is!=null && this.msgDiagnostico!=null && !this.emitDiagnosticResponseRead) {
  1477.             this.msgDiagnostico.logPersonalizzato("ricezioneRisposta.firstAccessRequestStream");
  1478.             this.emitDiagnosticResponseRead = true;
  1479.         }
  1480.     }
  1481. }
Created with JaCoCo 0.8.8.202204050719