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




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

  26. import java.sql.Connection;
  27. import java.util.ArrayList;
  28. import java.util.HashMap;
  29. import java.util.Iterator;
  30. import java.util.List;
  31. import java.util.Map;

  33. import org.openspcoop2.core.config.ResponseCachingConfigurazione;
  34. import org.openspcoop2.core.constants.CostantiConnettori;
  35. import org.openspcoop2.core.constants.CostantiLabel;
  36. import org.openspcoop2.core.constants.TipoPdD;
  37. import org.openspcoop2.core.id.IDSoggetto;
  38. import org.openspcoop2.core.registry.constants.CostantiRegistroServizi;
  39. import org.openspcoop2.core.transazioni.constants.TipoMessaggio;
  40. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  41. import org.openspcoop2.message.OpenSPCoop2MessageParseResult;
  42. import org.openspcoop2.message.OpenSPCoop2SoapMessage;
  43. import org.openspcoop2.message.constants.Costanti;
  44. import org.openspcoop2.message.constants.MessageRole;
  45. import org.openspcoop2.message.constants.MessageType;
  46. import org.openspcoop2.message.soap.TunnelSoapUtils;
  47. import org.openspcoop2.pdd.config.DBManager;
  48. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  49. import org.openspcoop2.pdd.config.Resource;
  50. import org.openspcoop2.pdd.core.Utilities;
  51. import org.openspcoop2.protocol.engine.builder.Imbustamento;
  52. import org.openspcoop2.protocol.engine.builder.Sbustamento;
  53. import org.openspcoop2.protocol.engine.driver.ProfiloDiCollaborazione;
  54. import org.openspcoop2.protocol.engine.driver.RepositoryBuste;
  55. import org.openspcoop2.protocol.engine.validator.Validatore;
  56. import org.openspcoop2.protocol.engine.validator.ValidazioneSintattica;
  57. import org.openspcoop2.protocol.sdk.Busta;
  58. import org.openspcoop2.protocol.sdk.BustaRawContent;
  59. import org.openspcoop2.protocol.sdk.IProtocolFactory;
  60. import org.openspcoop2.protocol.sdk.Integrazione;
  61. import org.openspcoop2.protocol.sdk.ProtocolMessage;
  62. import org.openspcoop2.protocol.sdk.Riscontro;
  63. import org.openspcoop2.protocol.sdk.Trasmissione;
  64. import org.openspcoop2.protocol.sdk.config.IProtocolManager;
  65. import org.openspcoop2.protocol.sdk.constants.FaseImbustamento;
  66. import org.openspcoop2.protocol.sdk.constants.FaseSbustamento;
  67. import org.openspcoop2.protocol.sdk.constants.RuoloMessaggio;
  68. import org.openspcoop2.protocol.sdk.constants.TipoOraRegistrazione;
  69. import org.openspcoop2.protocol.sdk.state.StatefulMessage;
  70. import org.openspcoop2.protocol.sdk.validator.IValidatoreErrori;
  71. import org.openspcoop2.protocol.sdk.validator.ProprietaValidazione;
  72. import org.openspcoop2.protocol.sdk.validator.ProprietaValidazioneErrori;
  73. import org.openspcoop2.utils.date.DateManager;
  74. import org.openspcoop2.utils.io.DumpByteArrayOutputStream;
  75. import org.openspcoop2.utils.transport.TransportUtils;
  76. import org.openspcoop2.utils.transport.http.HttpConstants;
  77. import org.openspcoop2.utils.transport.http.HttpUtilities;




  82. /**
  83.  * Classe utilizzata per effettuare consegne di messaggi Soap, attraverso
  84.  * l'invocazione di un server http. 
  85.  *
  86.  *
  87.  * @author Poli Andrea (apoli@link.it)
  88.  * @author $Author$
  89.  * @version $Rev$, $Date$
  90.  */

  92. public class ConnettoreNULLEcho extends ConnettoreBaseWithResponse {
  93.     
  94.     @Override
  95.     public String getProtocollo() {
  96.         return "";
  97.     }
  98.     
  99.     public static final String LOCATION = "govway://echo";
  100.     
  101.     private DumpByteArrayOutputStream requestBout = null;
  102.     
  103.     
  104.     


  107.     /* ********  METODI  ******** */

  109.     @Override
  110.     protected boolean initializePreSend(ResponseCachingConfigurazione responseCachingConfig, ConnettoreMsg request) {
  111.         
  112.         if(this.initialize(request, false, responseCachingConfig)==false){
  113.             return false;
  114.         }
  115.         
  116.         return true;
  117.         
  118.     }
  119.     
  120.     @Override
  121.     protected boolean send(ConnettoreMsg request) {

  123.         boolean generaTrasmissione = false;
  124.         if(this.properties.get(CostantiConnettori.CONNETTORE_NULL_ECHO_GENERA_TRASMISSIONE)!=null){
  125.             if("true".equalsIgnoreCase(this.properties.get(CostantiConnettori.CONNETTORE_NULL_ECHO_GENERA_TRASMISSIONE).trim()))
  126.                 generaTrasmissione = true;
  127.         }
  128.         boolean generaTrasmissioneInvertita = false;
  129.         if(this.properties.get(CostantiConnettori.CONNETTORE_NULL_ECHO_GENERA_TRASMISSIONE_INVERTITA)!=null){
  130.             if("true".equalsIgnoreCase(this.properties.get(CostantiConnettori.CONNETTORE_NULL_ECHO_GENERA_TRASMISSIONE_INVERTITA).trim()))
  131.                 generaTrasmissioneInvertita = true;
  132.         }
  133.         boolean generaTrasmissioneAndataRitorno = false;
  134.         if(this.properties.get(CostantiConnettori.CONNETTORE_NULL_ECHO_GENERA_TRASMISSIONE_ANDATA_RITORNO)!=null){
  135.             if("true".equalsIgnoreCase(this.properties.get(CostantiConnettori.CONNETTORE_NULL_ECHO_GENERA_TRASMISSIONE_ANDATA_RITORNO).trim()))
  136.                 generaTrasmissioneAndataRitorno = true;
  137.         }
  138.         
  139.         
  140.         this.codice = 200;
  141.         DBManager dbManager = DBManager.getInstance();
  142.         Resource resource = null;
  143.         
  144.         StatefulMessage state = new StatefulMessage(null, this.logger.getLogger());
  145.         
  146.         ValidazioneSintattica validatoreSintattico = null;
  147.         Validatore validatoreProtocollo = null;
  148.         @SuppressWarnings("unused")
  149.         BustaRawContent<?> headerProtocolloRisposta = null;
  150.         String protocol = null;
  151.         try{
  152.             IProtocolFactory<?> protocolFactory = this.getProtocolFactory();
  153.             IProtocolManager protocolManager = protocolFactory.createProtocolManager();
  154.             protocol = protocolFactory.getProtocol();
  155.             
  156.             // Tipologia di servizio
  157.             MessageType requestMessageType = this.requestMsg.getMessageType();
  158.             OpenSPCoop2SoapMessage soapMessageRequest = null;
  159.             if(this.debug)
  160.                 this.logger.debug("Tipologia Servizio: "+this.requestMsg.getServiceBinding());
  161.             if(this.isSoap){
  162.                 soapMessageRequest = this.requestMsg.castAsSoap();
  163.             }
  164.             
  165.             
  166.             // Collezione header di trasporto per dump
  167.             Map<String, List<String>> propertiesTrasportoDebug = null;
  168.             if(this.isDumpBinarioRichiesta()) {
  169.                 propertiesTrasportoDebug = new HashMap<>();
  170.             }
  171.             
  172.             
  173.             // Impostazione Content-Type
  174.             String contentTypeRichiesta = null;
  175.             if(this.debug)
  176.                 this.logger.debug("Impostazione content type...");
  177.             if(this.isSoap){
  178.                 if(this.sbustamentoSoap && soapMessageRequest.countAttachments()>0 && TunnelSoapUtils.isTunnelOpenSPCoopSoap(soapMessageRequest)){
  179.                     contentTypeRichiesta = TunnelSoapUtils.getContentTypeTunnelOpenSPCoopSoap(soapMessageRequest.getSOAPBody());
  180.                 }else{
  181.                     contentTypeRichiesta = this.requestMsg.getContentType();
  182.                 }
  183.                 if(contentTypeRichiesta==null){
  184.                     throw new Exception("Content-Type del messaggio da spedire non definito");
  185.                 }
  186.             }
  187.             else{
  188.                 contentTypeRichiesta = this.requestMsg.getContentType();
  189.                 // Content-Type non obbligatorio in REST
  190.             }
  191.             if(this.debug)
  192.                 this.logger.info("Impostazione Content-Type ["+contentTypeRichiesta+"]",false);
  193.             if(contentTypeRichiesta!=null){
  194.                 setRequestHeader(HttpConstants.CONTENT_TYPE, contentTypeRichiesta, this.logger, propertiesTrasportoDebug);
  195.             }
  196.             
  197.             
  198.             
  199.             // Impostazione timeout
  200.             if(this.debug)
  201.                 this.logger.debug("Impostazione timeout...");
  202.             int readConnectionTimeout = -1;
  203.             boolean readConnectionTimeoutConfigurazioneGlobale = true;
  204.             if(this.properties.get(CostantiConnettori.CONNETTORE_READ_CONNECTION_TIMEOUT)!=null){
  205.                 try{
  206.                     readConnectionTimeout = Integer.parseInt(this.properties.get(CostantiConnettori.CONNETTORE_READ_CONNECTION_TIMEOUT));
  207.                     readConnectionTimeoutConfigurazioneGlobale = this.properties.containsKey(CostantiConnettori.CONNETTORE_READ_CONNECTION_TIMEOUT_GLOBALE);
  208.                 }catch(Exception e){
  209.                     this.logger.error("Parametro "+CostantiConnettori.CONNETTORE_READ_CONNECTION_TIMEOUT+" errato",e);
  210.                 }
  211.             }
  212.             if(readConnectionTimeout==-1){
  213.                 readConnectionTimeout = HttpUtilities.HTTP_READ_CONNECTION_TIMEOUT;
  214.             }
  215.             if(this.debug)
  216.                 this.logger.info("Impostazione read timeout ["+readConnectionTimeout+"]",false);
  217.             
  218.             
  219.             // Impostazione Proprieta del trasporto
  220.             if(this.debug)
  221.                 this.logger.debug("Impostazione header di trasporto...");
  222.             this.forwardHttpRequestHeader();
  223.             if(this.propertiesTrasporto != null){
  224.                 Iterator<String> keys = this.propertiesTrasporto.keySet().iterator();
  225.                 while (keys.hasNext()) {
  226.                     String key = (String) keys.next();
  227.                     List<String> values = this.propertiesTrasporto.get(key);
  228.                     if(this.debug) {
  229.                         if(values!=null && !values.isEmpty()) {
  230.                             for (String value : values) {
  231.                                 this.logger.info("Set Transport Header ["+key+"]=["+value+"]",false);
  232.                             }
  233.                         }
  234.                     }
  235.                     
  236.                     setRequestHeader(key, values, this.logger, propertiesTrasportoDebug);
  237.                 }
  238.             }
  239.             
  240.             
  241.             
  242.             // Aggiunga del SoapAction Header in caso di richiesta SOAP
  243.             // spostato sotto il forwardHeader per consentire alle trasformazioni di modificarla
  244.             if(this.isSoap && this.sbustamentoSoap == false){
  245.                 if(this.debug)
  246.                     this.logger.debug("Impostazione soap action...");
  247.                 boolean existsTransportProperties = false;
  248.                 if(TransportUtils.containsKey(this.propertiesTrasporto, Costanti.SOAP11_MANDATORY_HEADER_HTTP_SOAP_ACTION)){
  249.                     this.soapAction = TransportUtils.getFirstValue(this.propertiesTrasporto, Costanti.SOAP11_MANDATORY_HEADER_HTTP_SOAP_ACTION);
  250.                     existsTransportProperties = (this.soapAction!=null);
  251.                 }
  252.                 if(!existsTransportProperties) {
  253.                     this.soapAction = soapMessageRequest.getSoapAction();
  254.                 }
  255.                 if(this.soapAction==null){
  256.                     this.soapAction="\"OpenSPCoop\"";
  257.                 }
  258.                 if(MessageType.SOAP_11.equals(this.requestMsg.getMessageType()) && !existsTransportProperties){
  259.                     // NOTA non quotare la soap action, per mantenere la trasparenza della PdD
  260.                     setRequestHeader(Costanti.SOAP11_MANDATORY_HEADER_HTTP_SOAP_ACTION,this.soapAction, propertiesTrasportoDebug);
  261.                 }
  262.                 if(this.debug)
  263.                     this.logger.info("SOAP Action inviata ["+this.soapAction+"]",false);
  264.             }
  265.             
  266.             
  267.             
  268.             // SIMULAZIONE WRITE_TO
  269.             //this.response = request.getRequestMessage();
  270.             boolean consumeRequestMessage = true;
  271.             if(this.debug)
  272.                 this.logger.debug("Serializzazione (consume-request-message:"+consumeRequestMessage+")...");
  273.             if(this.isDumpBinarioRichiesta()) {
  274.                 this.requestBout = new DumpByteArrayOutputStream(this.dumpBinario_soglia, this.dumpBinario_repositoryFile, this.idTransazione, 
  275.                         "NullEcho-"+TipoMessaggio.RICHIESTA_USCITA_DUMP_BINARIO.getValue());
  276.                 
  277.                 this.emitDiagnosticStartDumpBinarioRichiestaUscita();
  278.                 
  279.                 if(this.isSoap && this.sbustamentoSoap){
  280.                     this.logger.debug("Sbustamento...");
  281.                     TunnelSoapUtils.sbustamentoMessaggio(soapMessageRequest,this.requestBout);
  282.                 }else{
  283.                     this.requestMsg.writeTo(this.requestBout, consumeRequestMessage);
  284.                 }
  285.                 this.requestBout.flush();
  286.                 this.requestBout.close();
  287.                                     
  288.                 this.dataRichiestaInoltrata = DateManager.getDate();
  289.                 
  290.                 this.dumpBinarioRichiestaUscita(this.requestBout, requestMessageType, contentTypeRichiesta, this.location, propertiesTrasportoDebug);
  291.             }
  292.             else {
  293.                 this.requestBout = new DumpByteArrayOutputStream(this.dumpBinario_soglia, this.dumpBinario_repositoryFile, this.idTransazione, 
  294.                         "NullEcho-"+TipoMessaggio.RICHIESTA_USCITA_DUMP_BINARIO.getValue()); 
  295.                 if(this.isSoap && this.sbustamentoSoap){
  296.                     this.logger.debug("Sbustamento...");
  297.                     TunnelSoapUtils.sbustamentoMessaggio(soapMessageRequest,this.requestBout);
  298.                 }else{
  299.                     this.requestMsg.writeTo(this.requestBout, consumeRequestMessage);
  300.                 }
  301.                 this.requestBout.flush();
  302.                 this.requestBout.close();
  303.                 
  304.                 this.dataRichiestaInoltrata = DateManager.getDate();
  305.             }
  306.             
  307.             
  308.             
  309.             
  310.             
  311.             
  312.             /* ------------  PostOutRequestHandler ------------- */
  313.             this.postOutRequest();
  314.             
  315.             
  316.             
  317.             /* ------------  PreInResponseHandler ------------- */
  318.             this.preInResponse();
  319.             
  320.             // Lettura risposta parametri NotifierInputStream per la risposta
  321.             org.openspcoop2.utils.io.notifier.NotifierInputStreamParams notifierInputStreamParams = null;
  322.             if(this.preInResponseContext!=null){
  323.                 notifierInputStreamParams = this.preInResponseContext.getNotifierInputStreamParams();
  324.             }
  325.             
  326.             if(this.requestBout.isSerializedOnFileSystem()) {
  327.                 //System.out.println("FROM FILE ["+this.requestBout.getSerializedFile()+"]");
  328.                 this.isResponse = new java.io.FileInputStream(this.requestBout.getSerializedFile());
  329.             }
  330.             else {
  331.                 //System.out.println("FROM BUFF ["+this.requestBout.size()+"]");
  332.                 this.isResponse = new java.io.ByteArrayInputStream(this.requestBout.toByteArray());
  333.             }
  334.             
  335.             this.normalizeInputStreamResponse(readConnectionTimeout, readConnectionTimeoutConfigurazioneGlobale);
  336.             
  337.             this.initCheckContentTypeConfiguration();
  338.             
  339.             this.messageTypeResponse = this.requestMsg.getMessageType();
  340.             this.tipoRisposta = this.requestMsg.getContentType();
  341.             
  342.             if(this.isDumpBinarioRisposta()){
  343.                 this.dumpResponse(this.propertiesTrasportoRisposta);
  344.             }
  345.             
  346.             if(this.isResponse!=null) {
  347.                 this.emitDiagnosticResponseRead(this.isResponse);
  348.             }
  349.             
  350.             OpenSPCoop2MessageFactory messageFactory = Utilities.getOpenspcoop2MessageFactory(this.logger.getLogger(),this.requestMsg, this.requestInfo, MessageRole.RESPONSE);
  351.             OpenSPCoop2MessageParseResult pr = messageFactory.createMessage(this.messageTypeResponse,MessageRole.RESPONSE,
  352.                     this.requestMsg.getContentType(),
  353.                     this.isResponse,notifierInputStreamParams,
  354.                     this.openspcoopProperties.getAttachmentsProcessingMode());
  355.             // Non funziona con gli attachments: this.responseMsg = OpenSPCoop2MessageFactory.getMessageFactory().createMessage(request.getRequestMessage().getVersioneSoap(),(bout.toByteArray()),notifierInputStreamParams);
  356.             if(pr.getParseException()!=null){
  357.                 this.getPddContext().addObject(org.openspcoop2.core.constants.Costanti.CONTENUTO_RISPOSTA_NON_RICONOSCIUTO_PARSE_EXCEPTION, pr.getParseException());
  358.             }
  359.             this.responseMsg = pr.getMessage_throwParseException();
  360.             
  361.             validatoreSintattico = new ValidazioneSintattica(this.getPddContext(),state,this.responseMsg, this.openspcoopProperties.isReadQualifiedAttribute(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD), protocolFactory); 

  363.             if(validatoreSintattico.verifyProtocolPresence(TipoPdD.APPLICATIVA,null,RuoloMessaggio.RISPOSTA) && 
  364.                     !CostantiLabel.SDI_PROTOCOL_NAME.equals(protocolFactory.getProtocol())){ // evitare sdi per far funzionare il protocollo sdi con la sonda.
  365.                 
  366.                 // getBusta
  367.                 ProprietaValidazione property = new ProprietaValidazione();
  368.                 property.setValidazioneConSchema(false);
  369.                 property.setValidazioneProfiloCollaborazione(false);
  370.                 property.setValidazioneManifestAttachments(false);
  371.                 
  372.                 validatoreProtocollo = new Validatore(this.responseMsg,this.getPddContext(),property,null,
  373.                         this.openspcoopProperties.isReadQualifiedAttribute(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD), protocolFactory);
  374.                 
  375.                 if(validatoreProtocollo.validazioneSintattica() == false){
  376.                     throw new Exception("Busta non presente: "+validatoreProtocollo.getErrore().getDescrizione(protocolFactory));
  377.                 }
  378.                 
  379.                 // Leggo busta di richiesta
  380.                 Busta busta = validatoreProtocollo.getBusta();
  381.                 
  382.                 // informazione spcoopErrore
  383.                 IValidatoreErrori validatoreErrori = protocolFactory.createValidatoreErrori(state);
  384.                 ProprietaValidazioneErrori pValidazioneErrori = new ProprietaValidazioneErrori();
  385.                 pValidazioneErrori.setIgnoraEccezioniNonGravi(protocolManager.isIgnoraEccezioniNonGravi());
  386.                 boolean isBustaSPCoopErrore = validatoreErrori.isBustaErrore(busta,this.responseMsg,pValidazioneErrori);
  387.                 
  388.                 // Gestisco il manifest se il messaggio lo possiede
  389.                 boolean gestioneManifest = false;
  390.                 // La gestione manifest non la devo fare a questo livello.
  391.                 // Se mi arriva un messaggio senza manifest, vuol dire che era disabilitata e quindi anche nella risposta non ci deve essere
  392.                 // In egual misura se arriva un messaggio con manifest, significa che ci deve essere anche nella risposta
  393.                 // Poiche' la risposta e' esattamente uguale (nel body e negli allegati) alla richiesta, 
  394.                 // venendo costruita dai bytes della richiesta 
  395. //              if(this.responseMsg.countAttachments()>0){
  396. //                  javax.xml.soap.SOAPBody soapBody = this.responseMsg.getSOAPBody();
  397. //                  if(soapBody!=null){
  398. //                      Node childNode = org.openspcoop2.message.SoapUtils.getFirstNotEmptyChildNode(soapBody);
  399. //                      System.out.println("LocalName["+childNode.getLocalName()+"] ["+childNode.getNamespaceURI()+"]");
  400. //                      
  401. //                  }
  402. //              }
  403.                 
  404.                 // rimozione vecchia busta
  405.                 Sbustamento sbustatore = new Sbustamento(protocolFactory,state);
  406.                 ProtocolMessage protocolMessage = sbustatore.sbustamento(this.responseMsg,this.getPddContext(),
  407.                         busta,RuoloMessaggio.RICHIESTA, gestioneManifest, 
  408.                         this.openspcoopProperties.getProprietaManifestAttachments(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD),
  409.                         FaseSbustamento.PRE_CONSEGNA_RICHIESTA,this.requestInfo);
  410.                 if(protocolMessage!=null) {
  411.                     headerProtocolloRisposta = protocolMessage.getBustaRawContent();
  412.                     this.responseMsg = protocolMessage.getMessage(); // updated
  413.                 }
  414.                 
  415.                 // Creo busta di risposta solo se la busta di richiesta non conteneva una busta Errore
  416.                 if(!isBustaSPCoopErrore){
  417.             
  418.                     TipoOraRegistrazione tipoOraRegistrazione = this.openspcoopProperties.getTipoTempoBusta(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD);
  419.                     Busta bustaRisposta = busta.invertiBusta(tipoOraRegistrazione,protocolFactory.createTraduttore().toString(tipoOraRegistrazione));
  420.                 
  421.                     bustaRisposta.setProfiloDiCollaborazione(busta.getProfiloDiCollaborazione());
  422.                     bustaRisposta.setServizio(busta.getServizio());
  423.                     bustaRisposta.setVersioneServizio(busta.getVersioneServizio());
  424.                     bustaRisposta.setTipoServizio(busta.getTipoServizio());
  425.                     bustaRisposta.setAzione(busta.getAzione());
  426.                     
  427.                     bustaRisposta.setInoltro(busta.getInoltro(),busta.getInoltroValue());
  428.                     bustaRisposta.setConfermaRicezione(busta.isConfermaRicezione());
  429.                     
  430.                     if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ONEWAY.equals(busta.getProfiloDiCollaborazione()) &&
  431.                             busta.isConfermaRicezione() &&
  432.                             this.openspcoopProperties.isGestioneRiscontri(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD)){
  433.                         // Attendono riscontro
  434.                         Riscontro r = new Riscontro();
  435.                         r.setID(busta.getID());
  436.                         r.setOraRegistrazione(DateManager.getDate());
  437.                         r.setTipoOraRegistrazione(TipoOraRegistrazione.SINCRONIZZATO);
  438.                         bustaRisposta.addRiscontro(r);
  439.                         
  440.                     } else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_ASIMMETRICO.equals(busta.getProfiloDiCollaborazione()) &&
  441.                             busta.getRiferimentoMessaggio()==null){
  442.                         // devo generare ricevuta
  443.                         bustaRisposta.setTipoServizioCorrelato("SPC");
  444.                         bustaRisposta.setServizioCorrelato(busta.getServizio()+"Correlato");
  445.                     } else if(org.openspcoop2.protocol.sdk.constants.ProfiloDiCollaborazione.ASINCRONO_SIMMETRICO.equals(busta.getProfiloDiCollaborazione()) &&
  446.                             busta.getRiferimentoMessaggio()==null){
  447.                     
  448.                         // salvo messaggio sul database asincrono/repositoryBuste
  449.                     
  450.                         // get database
  451.                         try{
  452.                             resource = dbManager.getResource(this.openspcoopProperties.getIdentitaPortaDefault(protocolFactory.getProtocol(), this.requestInfo),"ConnettoreNullEcho",busta.getID());
  453.                         }catch(Exception e){
  454.                             throw new Exception("Risorsa non ottenibile",e);
  455.                         }
  456.                         if(resource==null)
  457.                             throw new Exception("Risorsa is null");
  458.                         if(resource.getResource() == null)
  459.                             throw new Exception("Connessione is null");
  460.                         Connection connectionDB = (Connection) resource.getResource();
  461.                         //POOL,TRANSACTIONISOLATION:connectionDB.setTransactionIsolation(DBManager.getTransactionIsolationLevel());
  462.                         
  463.                         state.setConnectionDB(connectionDB);
  464.                         
  465.                         // repository
  466.                         RepositoryBuste repositoryBuste = new RepositoryBuste(state, true,protocolFactory);
  467.                         repositoryBuste.registraBustaIntoInBox(busta, new ArrayList<>() ,
  468.                                 OpenSPCoop2Properties.getInstance().getRepositoryIntervalloScadenzaMessaggi());
  469.                         Integrazione infoIntegrazione = new Integrazione();
  470.                         infoIntegrazione.setIdModuloInAttesa(null);
  471.                         repositoryBuste.aggiornaInfoIntegrazioneIntoInBox(busta.getID(),infoIntegrazione);
  472.                     
  473.                         // asincrono
  474.                         ProfiloDiCollaborazione profiloCollaborazione = new ProfiloDiCollaborazione(state,protocolFactory);
  475.                         profiloCollaborazione.asincronoSimmetrico_registraRichiestaRicevuta(busta.getID(),busta.getCollaborazione(),
  476.                                 busta.getTipoServizioCorrelato(),busta.getServizioCorrelato(),busta.getVersioneServizioCorrelato(),true,
  477.                                 this.openspcoopProperties.getRepositoryIntervalloScadenzaMessaggi());
  478.                     
  479.                         // commit
  480.                         try{
  481.                             connectionDB.setAutoCommit(false);
  482.                             state.executePreparedStatement(); 
  483.                 
  484.                             connectionDB.commit();
  485.                             connectionDB.setAutoCommit(true);
  486.                         }catch (Exception e) {  
  487.                             this.logger.error("Riscontrato errore durante la gestione transazione del DB per la richiesta: "+e.getMessage());
  488.                             // Rollback quanto effettuato (se l'errore e' avvenuto sul commit, o prima nell'execute delle PreparedStatement)
  489.                             try{
  490.                                 connectionDB.rollback();
  491.                             }catch(Exception er){
  492.                                 // ignore
  493.                             }
  494.                             state.closePreparedStatement(); // Chiude le PreparedStatement aperte(e non eseguite) per il save del Msg
  495.                         }finally {
  496.                             // Ripristino connessione
  497.                             try{
  498.                                 connectionDB.setAutoCommit(true);
  499.                             }catch(Exception er){
  500.                                 // ignore
  501.                             }
  502.                         }
  503.                     
  504.                     }
  505.                 
  506.                     // Riferimento Messaggio
  507.                     bustaRisposta.setRiferimentoMessaggio(busta.getID());
  508.                     
  509.                     // Identificativo Messaggio
  510.                     String dominio = null;
  511.                     if(request.getConnectorProperties()!=null)
  512.                         dominio = request.getConnectorProperties().get("identificativo-porta");
  513.                     if(dominio==null){
  514.                         dominio = protocolFactory.createTraduttore().getIdentificativoPortaDefault(new IDSoggetto(busta.getTipoDestinatario(), busta.getDestinatario()));
  515.                     }
  516.                     String idBustaRisposta = null;
  517.                     Imbustamento imbustatore = new Imbustamento(this.logger.getLogger(), protocolFactory, state);
  518.                     try{
  519.                         idBustaRisposta = 
  520.                             imbustatore.buildID(new IDSoggetto(busta.getTipoDestinatario(), busta.getDestinatario(), dominio), 
  521.                                     null, 
  522.                                     this.openspcoopProperties.getGestioneSerializableDBAttesaAttiva(),
  523.                                     this.openspcoopProperties.getGestioneSerializableDBCheckInterval(),
  524.                                     RuoloMessaggio.RISPOSTA);
  525.                     }catch(Exception e){
  526.                         // rilancio
  527.                         throw e;
  528.                     }
  529.                     bustaRisposta.setID(idBustaRisposta);
  530.                     
  531.                     if(generaTrasmissioneAndataRitorno){
  532.                         Trasmissione t = new Trasmissione();
  533.                         t.setTipoOrigine(busta.getTipoMittente());
  534.                         t.setOrigine(busta.getMittente());
  535.                         t.setIdentificativoPortaOrigine(busta.getIdentificativoPortaMittente());
  536.                         t.setIndirizzoOrigine(busta.getIndirizzoMittente());
  537.                         
  538.                         t.setTipoDestinazione(busta.getTipoDestinatario());
  539.                         t.setDestinazione(busta.getDestinatario());
  540.                         t.setIdentificativoPortaDestinazione(busta.getIdentificativoPortaDestinatario());
  541.                         t.setIndirizzoDestinazione(busta.getIndirizzoDestinatario());
  542.                         
  543.                         t.setOraRegistrazione(busta.getOraRegistrazione());
  544.                         t.setTempo(busta.getTipoOraRegistrazione(), busta.getTipoOraRegistrazioneValue());
  545.                         bustaRisposta.addTrasmissione(t);
  546.                     }
  547.                     if(generaTrasmissione || generaTrasmissioneInvertita || generaTrasmissioneAndataRitorno){
  548.                         Trasmissione t = new Trasmissione();
  549.                         if(generaTrasmissione || generaTrasmissioneAndataRitorno){
  550.                             t.setTipoOrigine(bustaRisposta.getTipoMittente());
  551.                             t.setOrigine(bustaRisposta.getMittente());
  552.                             t.setIdentificativoPortaOrigine(bustaRisposta.getIdentificativoPortaMittente());
  553.                             t.setIndirizzoOrigine(bustaRisposta.getIndirizzoMittente());
  554.                             
  555.                             t.setTipoDestinazione(bustaRisposta.getTipoDestinatario());
  556.                             t.setDestinazione(bustaRisposta.getDestinatario());
  557.                             t.setIdentificativoPortaDestinazione(bustaRisposta.getIdentificativoPortaDestinatario());
  558.                             t.setIndirizzoDestinazione(bustaRisposta.getIndirizzoDestinatario());
  559.                         }
  560.                         if(generaTrasmissioneInvertita){
  561.                             // invertita
  562.                             t.setTipoOrigine(bustaRisposta.getTipoDestinatario());
  563.                             t.setOrigine(bustaRisposta.getDestinatario());
  564.                             t.setIdentificativoPortaOrigine(bustaRisposta.getIdentificativoPortaDestinatario());
  565.                             t.setIndirizzoOrigine(bustaRisposta.getIndirizzoDestinatario());
  566.                             
  567.                             t.setTipoDestinazione(bustaRisposta.getTipoMittente());
  568.                             t.setDestinazione(bustaRisposta.getMittente());
  569.                             t.setIdentificativoPortaDestinazione(bustaRisposta.getIdentificativoPortaMittente());
  570.                             t.setIndirizzoDestinazione(bustaRisposta.getIndirizzoMittente());
  571.                         }
  572.                         t.setOraRegistrazione(bustaRisposta.getOraRegistrazione());
  573.                         t.setTempo(bustaRisposta.getTipoOraRegistrazione(), bustaRisposta.getTipoOraRegistrazioneValue());
  574.                         bustaRisposta.addTrasmissione(t);
  575.                     }
  576.                                 
  577.                     // imbustamento nuova busta
  578.                     Integrazione integrazione = new Integrazione();
  579.                     integrazione.setStateless(true);
  580.                     
  581.                     ProtocolMessage protocolMessageRisposta = imbustatore.imbustamentoRisposta(this.responseMsg,this.getPddContext(),
  582.                             bustaRisposta,busta,integrazione,gestioneManifest,false,
  583.                             this.openspcoopProperties.getProprietaManifestAttachments(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD),
  584.                             FaseImbustamento.PRIMA_SICUREZZA_MESSAGGIO);
  585.                     if(protocolMessageRisposta!=null && !protocolMessageRisposta.isPhaseUnsupported()) {
  586.                         this.responseMsg = protocolMessageRisposta.getMessage(); // updated
  587.                     }
  588.                     
  589.                     protocolMessageRisposta = imbustatore.imbustamentoRisposta(this.responseMsg,this.getPddContext(),
  590.                             bustaRisposta,busta,integrazione,gestioneManifest,false,
  591.                             this.openspcoopProperties.getProprietaManifestAttachments(CostantiRegistroServizi.IMPLEMENTAZIONE_STANDARD),
  592.                             FaseImbustamento.DOPO_SICUREZZA_MESSAGGIO);
  593.                     if(protocolMessageRisposta!=null && !protocolMessageRisposta.isPhaseUnsupported()) {
  594.                         this.responseMsg = protocolMessageRisposta.getMessage(); // updated
  595.                     }

  597.                 }
  598.                 else{
  599.                     // rimuovo il FAULT.
  600.                     if(this.responseMsg instanceof OpenSPCoop2SoapMessage){
  601.                         OpenSPCoop2SoapMessage soapMessage = this.responseMsg.castAsSoap();
  602.                         if(soapMessage.hasSOAPFault()){
  603.                             soapMessage.getSOAPBody().removeChild(soapMessage.getSOAPBody().getFault());
  604.                         }
  605.                     }
  606.                 }
  607.             }
  608.             
  609.             // content length
  610.             if(this.responseMsg!=null){
  611.                 this.contentLength = this.responseMsg.getIncomingMessageContentLength();
  612.             }
  613.             
  614.         }catch(Exception e){
  615.             this.eccezioneProcessamento = e;
  616.             String msgErrore = this.readExceptionMessageFromException(e);
  617.             if(this.generateErrorWithConnectorPrefix) {
  618.                 this.errore = "Riscontrato errore durante l'echo del messaggio: "+msgErrore;
  619.             }
  620.             else {
  621.                 this.errore = msgErrore;
  622.             }
  623.             this.logger.error("Riscontrato errore durante l'echo del messaggio: "+msgErrore,e);
  624.             return false;
  625.         }finally{
  626.                     
  627.             // *** GB ***
  628.             if(validatoreSintattico!=null){
  629.                 validatoreSintattico.setHeaderSOAP(null);
  630.             }
  631.             validatoreSintattico = null;
  632.             if(validatoreProtocollo!=null){
  633.                 if(validatoreProtocollo.getValidatoreSintattico()!=null){
  634.                     validatoreProtocollo.getValidatoreSintattico().setHeaderSOAP(null);
  635.                 }
  636.                 validatoreProtocollo.setValidatoreSintattico(null);
  637.             }
  638.             validatoreProtocollo = null;
  639.             headerProtocolloRisposta = null;
  640.             // *** GB ***
  641.             
  642.             // release database
  643.             dbManager.releaseResource(this.openspcoopProperties.getIdentitaPortaDefault(protocol, this.requestInfo),
  644.                     "ConnettoreNullEcho", resource);
  645.         }
  646.         
  647.         return true;
  648.     }
  649.     
  650.     private void setRequestHeader(String key, String value, ConnettoreLogger logger, Map<String, List<String>> propertiesTrasportoDebug) throws Exception {
  651.         List<String> list = new ArrayList<>(); 
  652.         list.add(value);
  653.         this.setRequestHeader(key, list, logger, propertiesTrasportoDebug);
  654.     }
  655.     private void setRequestHeader(String key, List<String> values, ConnettoreLogger logger, Map<String, List<String>> propertiesTrasportoDebug) throws Exception {
  656.         
  657.         if(this.debug) {
  658.             if(values!=null && !values.isEmpty()) {
  659.                 for (String value : values) {
  660.                     this.logger.info("Set proprietà trasporto ["+key+"]=["+value+"]",false);        
  661.                 }
  662.             }
  663.         }
  664.         setRequestHeader(key, values, propertiesTrasportoDebug);
  665.         
  666.     }
  667.     @Override
  668.     protected void setRequestHeader(String key,List<String> values) throws Exception {
  669.         this.propertiesTrasportoRisposta.put(key, values);
  670.     }
  671.     
  672.     /**
  673.      * Ritorna l'informazione su dove il connettore sta spedendo il messaggio
  674.      * 
  675.      * @return location di inoltro del messaggio
  676.      */
  677.     @Override
  678.     public String getLocation() throws ConnettoreException {
  679.         // Il connettore NULL_ECHO ho possiede possibilita' di consegnare su di una url
  680.         //return ConnettoreUtils.buildLocationWithURLBasedParameter(this.requestMsg, this.propertiesUrlBased, LOCATION);
  681.         return LOCATION;
  682.     }

  684.     @Override
  685.     public void disconnect() throws ConnettoreException {
  686.         try {
  687.             if(this.requestBout!=null) {
  688.                 this.requestBout.clearResources();
  689.             }
  690.         }catch(Throwable t) {
  691.             this.logger.error("Release resources failed: "+t.getMessage(),t);
  692.         }
  693.     }
  694. }




Created with JaCoCo 0.8.8.202204050719