ConnettoreSAAJ.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.net.HttpURLConnection;
  27. import java.net.URL;
  28. import java.net.URLConnection;
  29. import java.util.ArrayList;
  30. import java.util.HashMap;
  31. import java.util.Iterator;
  32. import java.util.List;
  33. import java.util.Map;

  35. import javax.xml.soap.MimeHeader;
  36. import javax.xml.soap.SOAPConnection;
  37. import javax.xml.soap.SOAPConnectionFactory;
  38. import javax.xml.soap.SOAPMessage;

  40. import org.openspcoop2.core.config.ResponseCachingConfigurazione;
  41. import org.openspcoop2.core.constants.CostantiConnettori;
  42. import org.openspcoop2.core.transazioni.constants.TipoMessaggio;
  43. import org.openspcoop2.message.MessageUtils;
  44. import org.openspcoop2.message.OpenSPCoop2MessageFactory;
  45. import org.openspcoop2.message.OpenSPCoop2SoapMessage;
  46. import org.openspcoop2.message.constants.Costanti;
  47. import org.openspcoop2.message.constants.MessageRole;
  48. import org.openspcoop2.message.constants.MessageType;
  49. import org.openspcoop2.message.constants.ServiceBinding;
  50. import org.openspcoop2.pdd.config.CostantiProprieta;
  51. import org.openspcoop2.pdd.core.Utilities;
  52. import org.openspcoop2.pdd.mdb.ConsegnaContenutiApplicativi;
  53. import org.openspcoop2.utils.UtilsException;
  54. import org.openspcoop2.utils.date.DateManager;
  55. import org.openspcoop2.utils.io.Base64Utilities;
  56. import org.openspcoop2.utils.io.DumpByteArrayOutputStream;
  57. import org.openspcoop2.utils.resources.Charset;
  58. import org.openspcoop2.utils.transport.TransportResponseContext;
  59. import org.openspcoop2.utils.transport.TransportUtils;
  60. import org.openspcoop2.utils.transport.http.HttpConstants;
  61. import org.openspcoop2.utils.transport.http.HttpRequestMethod;
  62. import org.openspcoop2.utils.transport.http.HttpUtilities;
  63. import org.openspcoop2.utils.transport.http.RFC2047Encoding;
  64. import org.openspcoop2.utils.transport.http.RFC2047Utilities;

  66. /**
  67.  * Classe utilizzata per effettuare consegne di messaggi Soap, attraverso
  68.  * l'invocazione di un server http. 
  69.  *
  70.  *
  71.  * @author Poli Andrea (apoli@link.it)
  72.  * @author $Author$
  73.  * @version $Rev$, $Date$
  74.  */

  76. public class ConnettoreSAAJ extends ConnettoreBaseWithResponse {

  78.     @Override
  79.     public String getProtocollo() {
  80.         return "HTTP";
  81.     }
  82.     
  83.     public static final String ENDPOINT_TYPE = "saaj";
  84.     

  86.     /** Connessione */
  87.     private SOAPConnection connection = null;

  89.     private SOAPMessage soapRequestMessage = null;
  90.     
  91.     
  92.     /* ********  METODI  ******** */

  94.     @Override
  95.     protected boolean initializePreSend(ResponseCachingConfigurazione responseCachingConfig, ConnettoreMsg request) {
  96.         
  97.         if(this.initialize(request, true, responseCachingConfig)==false){
  98.             return false;
  99.         }
  100.         
  101.         return true;
  102.         
  103.     }
  104.     
  105.     @Override
  106.     protected boolean send(ConnettoreMsg request) {

  108.         // analsi i parametri specifici per il connettore
  109.         if(this.properties.get(CostantiConnettori.CONNETTORE_LOCATION)==null){
  110.             this.errore = "Proprieta' '"+CostantiConnettori.CONNETTORE_LOCATION+"' non fornita e richiesta da questo tipo di connettore ["+request.getTipoConnettore()+"]";
  111.             return false;
  112.         }

  114.         return sendSAAJ();

  116.     }


  119.     /**
  120.      * Si occupa di effettuare la consegna SOAP (invocazione di un WebService).
  121.      * Si aspetta di ricevere una risposta non sbustata.
  122.      *
  123.      * @return true in caso di consegna con successo, false altrimenti
  124.      * 
  125.      */
  126.     private boolean sendSAAJ(){
  127.         int connectionTimeout = -1;
  128.         boolean connectionTimeoutConfigurazioneGlobale = true;
  129.         int readConnectionTimeout = -1;
  130.         boolean readConnectionTimeoutConfigurazioneGlobale = true;
  131.         try{
  132.             // Impostazione timeout
  133.             if(this.debug)
  134.                 this.logger.debug("Impostazione timeout...");
  135.             if(this.properties.get(CostantiConnettori.CONNETTORE_CONNECTION_TIMEOUT)!=null){
  136.                 try{
  137.                     connectionTimeout = Integer.parseInt(this.properties.get(CostantiConnettori.CONNETTORE_CONNECTION_TIMEOUT));
  138.                     connectionTimeoutConfigurazioneGlobale = this.properties.containsKey(CostantiConnettori.CONNETTORE_CONNECTION_TIMEOUT_GLOBALE);
  139.                 }catch(Exception e){
  140.                     this.logger.error("Parametro '"+CostantiConnettori.CONNETTORE_CONNECTION_TIMEOUT+"' errato",e);
  141.                 }
  142.             }
  143.             if(connectionTimeout==-1){
  144.                 connectionTimeout = HttpUtilities.HTTP_CONNECTION_TIMEOUT;
  145.             }
  146.             if(this.properties.get(CostantiConnettori.CONNETTORE_READ_CONNECTION_TIMEOUT)!=null){
  147.                 try{
  148.                     readConnectionTimeout = Integer.parseInt(this.properties.get(CostantiConnettori.CONNETTORE_READ_CONNECTION_TIMEOUT));
  149.                     readConnectionTimeoutConfigurazioneGlobale = this.properties.containsKey(CostantiConnettori.CONNETTORE_READ_CONNECTION_TIMEOUT_GLOBALE);
  150.                 }catch(Exception e){
  151.                     this.logger.error("Parametro '"+CostantiConnettori.CONNETTORE_READ_CONNECTION_TIMEOUT+"' errato",e);
  152.                 }
  153.             }
  154.             if(readConnectionTimeout==-1){
  155.                 readConnectionTimeout = HttpUtilities.HTTP_READ_CONNECTION_TIMEOUT;
  156.             }
  157.             if(this.debug)
  158.                 this.logger.info("Impostazione http timeout CT["+connectionTimeout+"] RT["+readConnectionTimeout+"]...",false);
  159.             
  160.             // check validity message
  161.             if(ServiceBinding.SOAP.equals(this.requestMsg.getServiceBinding())==false) {
  162.                 throw new Exception("Connettore utilizzabile solamente in un contesto SOAP (trovato: "+this.requestMsg.getServiceBinding()+")");
  163.             }
  164.             
  165.             // check validita URL
  166.             if(this.debug)
  167.                 this.logger.debug("Check validita URL...");
  168.             this.location = this.properties.get(CostantiConnettori.CONNETTORE_LOCATION);
  169.             this.location = ConnettoreUtils.buildLocationWithURLBasedParameter(this.logger!=null ? this.logger.getLogger() : null, this.requestMsg, ENDPOINT_TYPE, this.propertiesUrlBased, this.location,
  170.                     this.getProtocolFactory(), this.idModulo);
  171.             
  172.             URL urlTest = new URL( this.location );
  173.             URLConnection connectionTest = urlTest.openConnection();
  174.             HttpURLConnection httpConnTest = (HttpURLConnection) connectionTest;
  175.             httpConnTest.setRequestMethod( HttpRequestMethod.POST.name() );
  176.             httpConnTest.setConnectTimeout(connectionTimeout);
  177.             httpConnTest.setReadTimeout(readConnectionTimeout);
  178.             httpConnTest.setDoOutput(true);
  179.             java.io.OutputStream outTest = httpConnTest.getOutputStream();
  180.             outTest.close();
  181.             httpConnTest.disconnect();

  183.             
  184.             
  185.             // Check tipo di messaggio
  186.             MessageType requestMessageType = this.requestMsg.getMessageType();
  187.             if(ServiceBinding.SOAP.equals(this.requestMsg.getServiceBinding())==false){
  188.                 throw new Exception("Connettore utilizzabile solamente per tipologia di servizio SOAP");
  189.             }
  190.             OpenSPCoop2SoapMessage soapRequestMessage = this.requestMsg.castAsSoap();
  191.             this.soapRequestMessage = MessageUtils.getSOAPMessage(soapRequestMessage, false, this.idTransazione);

  193.             // Collezione header di trasporto per dump
  194.             Map<String, List<String>> propertiesTrasportoDebug = null;
  195.             if(this.isDumpBinarioRichiesta()) {
  196.                 propertiesTrasportoDebug = new HashMap<>();
  197.             }
  198.             
  199.             
  200.             // impostazione property
  201.             if(this.debug)
  202.                 this.logger.debug("PrefixOptimization...");
  203.             String prefixOptimization = "true";
  204.             if(this.properties.get("prefix-optimization")!=null){
  205.                 if("false".equalsIgnoreCase(this.properties.get("prefix-optimization")) )
  206.                     prefixOptimization = "false";
  207.                 this.logger.info("Prefix Optimization = '"+prefixOptimization+"'",false);
  208.                 //AxisProperties.setProperty(AxisEngine.PROP_ENABLE_NAMESPACE_PREFIX_OPTIMIZATION,prefixOptimization);          
  209.             }
  210.             

  212.             // Consegna
  213.             if(this.debug)
  214.                 this.logger.debug("Creazione connessione...");  
  215.             OpenSPCoop2MessageFactory messageFactory = Utilities.getOpenspcoop2MessageFactory(this.logger.getLogger(),this.requestMsg, this.requestInfo, MessageRole.NONE);
  216.             SOAPConnectionFactory soapConnFactory = messageFactory.getSOAPConnectionFactory();
  217.             this.connection = soapConnFactory.createConnection();
  218.                                 
  219.             
  220.             try{
  221.                 // Impostazione Proprieta del trasporto
  222.                 
  223.                 // Impostazione Content-Type
  224.                 String contentTypeRichiesta = null;
  225.                 if(this.debug)
  226.                     this.logger.debug("Impostazione content type...");
  227.                 if(this.isSoap){
  228.                     contentTypeRichiesta = this.requestMsg.getContentType();
  229.                     if(contentTypeRichiesta==null){
  230.                         throw new Exception("Content-Type del messaggio da spedire non definito");
  231.                     }
  232.                 }
  233.                 else{
  234.                     contentTypeRichiesta = this.requestMsg.getContentType();
  235.                     // Content-Type non obbligatorio in REST
  236.                 }
  237.                 if(this.debug)
  238.                     this.logger.info("Impostazione Content-Type ["+contentTypeRichiesta+"]",false);
  239.                 if(contentTypeRichiesta!=null){
  240.                     setRequestHeader(HttpConstants.CONTENT_TYPE, contentTypeRichiesta, propertiesTrasportoDebug);
  241.                 }
  242.                 
  243.                 

  245.                 // Authentication BASIC
  246.                 if(this.debug)
  247.                     this.logger.debug("Impostazione autenticazione...");
  248.                 String user = null;
  249.                 String password = null;
  250.                 if(this.credenziali!=null){
  251.                     user = this.credenziali.getUser();
  252.                     password = this.credenziali.getPassword();
  253.                 }else{
  254.                     user = this.properties.get(CostantiConnettori.CONNETTORE_USERNAME);
  255.                     password = this.properties.get(CostantiConnettori.CONNETTORE_PASSWORD);
  256.                 }
  257.                 if(user!=null && password!=null){
  258.                     String authentication = user + ":" + password;
  259.                     authentication = HttpConstants.AUTHORIZATION_PREFIX_BASIC + Base64Utilities.encodeAsString(authentication.getBytes());
  260.                     setRequestHeader(HttpConstants.AUTHORIZATION,authentication, propertiesTrasportoDebug);
  261.                     if(this.debug)
  262.                         this.logger.info("Impostazione autenticazione (username:"+user+" password:"+password+") ["+authentication+"]",false);
  263.                 }
  264.                 
  265.                 // Impostazione timeout
  266.                 if(this.debug)
  267.                     this.logger.debug("Set timeout...");
  268.                 //TODO: connection.setTimeout(readConnectionTimeout);
  269.                 
  270.                 
  271.                 
  272.                 // Impostazione Proprieta del trasporto
  273.                 if(this.debug)
  274.                     this.logger.debug("Impostazione header di trasporto...");
  275.                 boolean encodingRFC2047 = false;
  276.                 Charset charsetRFC2047 = null;
  277.                 RFC2047Encoding encodingAlgorithmRFC2047 = null;
  278.                 boolean validazioneHeaderRFC2047 = false;
  279.                 if(this.idModulo!=null){
  280.                     if(ConsegnaContenutiApplicativi.ID_MODULO.equals(this.idModulo)){
  281.                         encodingRFC2047 = this.openspcoopProperties.isEnabledEncodingRFC2047HeaderValueConsegnaContenutiApplicativi();
  282.                         charsetRFC2047 = this.openspcoopProperties.getCharsetEncodingRFC2047HeaderValueConsegnaContenutiApplicativi();
  283.                         encodingAlgorithmRFC2047 = this.openspcoopProperties.getEncodingRFC2047HeaderValueConsegnaContenutiApplicativi();
  284.                         validazioneHeaderRFC2047 = this.openspcoopProperties.isEnabledValidazioneRFC2047HeaderNameValueConsegnaContenutiApplicativi();
  285.                     }else{
  286.                         encodingRFC2047 = this.openspcoopProperties.isEnabledEncodingRFC2047HeaderValueInoltroBuste();
  287.                         charsetRFC2047 = this.openspcoopProperties.getCharsetEncodingRFC2047HeaderValueInoltroBuste();
  288.                         encodingAlgorithmRFC2047 = this.openspcoopProperties.getEncodingRFC2047HeaderValueInoltroBuste();
  289.                         validazioneHeaderRFC2047 = this.openspcoopProperties.isEnabledValidazioneRFC2047HeaderNameValueInoltroBuste();
  290.                     }
  291.                     
  292.                     encodingRFC2047 = CostantiProprieta.isConnettoriHeaderValueEncodingRFC2047RequestEnabled(this.proprietaPorta, encodingRFC2047);
  293.                     charsetRFC2047 = CostantiProprieta.getConnettoriHeaderValueEncodingRFC2047RequestCharset(this.proprietaPorta, charsetRFC2047);
  294.                     encodingAlgorithmRFC2047 = CostantiProprieta.getConnettoriHeaderValueEncodingRFC2047RequestType(this.proprietaPorta, encodingAlgorithmRFC2047);
  295.                     validazioneHeaderRFC2047 = CostantiProprieta.isConnettoriHeaderValidationRequestEnabled(this.proprietaPorta, validazioneHeaderRFC2047);
  296.                 }
  297.                 this.forwardHttpRequestHeader();
  298.                 if(this.propertiesTrasporto != null){
  299.                     Iterator<String> keys = this.propertiesTrasporto.keySet().iterator();
  300.                     while (keys.hasNext()) {
  301.                         String key = (String) keys.next();
  302.                         if(HttpConstants.USER_AGENT.equalsIgnoreCase(key)){
  303.                             continue;
  304.                         }
  305.                         List<String> values = this.propertiesTrasporto.get(key);
  306.                         if(this.debug) {
  307.                             if(values!=null && !values.isEmpty()) {
  308.                                 for (String value : values) {
  309.                                     this.logger.info("Set Transport Header ["+key+"]=["+value+"]",false);
  310.                                 }
  311.                             }
  312.                         }
  313.                         
  314.                         if(encodingRFC2047){
  315.                             List<String> valuesEncoded = new ArrayList<>();
  316.                             if(values!=null && !values.isEmpty()) {
  317.                                 for (String value : values) {
  318.                                     if(RFC2047Utilities.isAllCharactersInCharset(value, charsetRFC2047)==false){
  319.                                         String encoded = RFC2047Utilities.encode(new String(value), charsetRFC2047, encodingAlgorithmRFC2047);
  320.                                         //System.out.println("@@@@ CODIFICA ["+value+"] in ["+encoded+"]");
  321.                                         if(this.debug)
  322.                                             this.logger.info("RFC2047 Encoded value in ["+encoded+"] (charset:"+charsetRFC2047+" encoding-algorithm:"+encodingAlgorithmRFC2047+")",false);
  323.                                         valuesEncoded.add(encoded);
  324.                                     }
  325.                                     else{
  326.                                         valuesEncoded.add(value);
  327.                                     }
  328.                                 }
  329.                             }
  330.                             setRequestHeader(validazioneHeaderRFC2047, key, valuesEncoded, this.logger, propertiesTrasportoDebug);
  331.                         }
  332.                         else{
  333.                             setRequestHeader(validazioneHeaderRFC2047, key, values, this.logger, propertiesTrasportoDebug);
  334.                         }
  335.                     }
  336.                 }
  337.                 
  338.                 
  339.                 
  340.                 
  341.                 // Aggiunta del SoapAction Header in caso di richiesta SOAP
  342.                 // spostato sotto il forwardHeader per consentire alle trasformazioni di modificarla
  343.                 if(this.isSoap && this.sbustamentoSoap == false){
  344.                     if(this.debug)
  345.                         this.logger.debug("Impostazione soap action...");
  346.                     boolean existsTransportProperties = false;
  347.                     if(TransportUtils.containsKey(this.propertiesTrasporto, Costanti.SOAP11_MANDATORY_HEADER_HTTP_SOAP_ACTION)){
  348.                         this.soapAction = TransportUtils.getFirstValue(this.propertiesTrasporto, Costanti.SOAP11_MANDATORY_HEADER_HTTP_SOAP_ACTION);
  349.                         existsTransportProperties = (this.soapAction!=null);
  350.                     }
  351.                     if(!existsTransportProperties) {
  352.                         this.soapAction = soapRequestMessage.getSoapAction();
  353.                     }
  354.                     if(this.soapAction==null){
  355.                         this.soapAction="\"OpenSPCoop\"";
  356.                     }
  357.                     if(MessageType.SOAP_11.equals(this.requestMsg.getMessageType()) && !existsTransportProperties){
  358.                         // NOTA non quotare la soap action, per mantenere la trasparenza della PdD
  359.                         setRequestHeader(Costanti.SOAP11_MANDATORY_HEADER_HTTP_SOAP_ACTION,this.soapAction, propertiesTrasportoDebug);
  360.                     }
  361.                     if(this.debug)
  362.                         this.logger.info("SOAP Action inviata ["+this.soapAction+"]",false);
  363.                 }
  364.                 
  365.                 
  366.                 
  367.                 if(this.isDumpBinarioRichiesta()) {
  368.                     DumpByteArrayOutputStream bout = new DumpByteArrayOutputStream(this.dumpBinario_soglia, this.dumpBinario_repositoryFile, this.idTransazione, 
  369.                             TipoMessaggio.RICHIESTA_USCITA_DUMP_BINARIO.getValue());
  370.                     try {
  371.                         this.emitDiagnosticStartDumpBinarioRichiestaUscita();
  372.                         
  373.                         this.requestMsg.writeTo(bout, false);
  374.                         bout.flush();
  375.                         bout.close();
  376.                         
  377.                         this.dumpBinarioRichiestaUscita(bout, requestMessageType, contentTypeRichiesta, this.location, propertiesTrasportoDebug);
  378.                     }finally {
  379.                         try {
  380.                             bout.clearResources();
  381.                         }catch(Throwable t) {
  382.                             this.logger.error("Release resources failed: "+t.getMessage(),t);
  383.                         }
  384.                     }
  385.                 }
  386.                                 
  387.                 // Send
  388.                 if(this.debug)
  389.                     this.logger.debug("Send...");
  390.                 
  391.                 SOAPMessage soapMsg = this.connection.call( this.soapRequestMessage, this.location);
  392.                 
  393.                 this.dataRichiestaInoltrata = DateManager.getDate();
  394.                 
  395.                 this.responseMsg = messageFactory.
  396.                         createMessage(this.requestMsg.getMessageType(),MessageRole.RESPONSE,soapMsg);
  397.                 
  398.                 this.dataAccettazioneRisposta = DateManager.getDate();
  399.                 
  400.             }catch(javax.xml.soap.SOAPException sendError){
  401.                 this.eccezioneProcessamento = sendError;
  402.                 String errorMsg = this.readExceptionMessageFromException(sendError);
  403.                 this.connection.close();
  404.                 this.errore = "Errore avvenuto durante la consegna SOAP (lettura risposta): " + errorMsg;
  405.                 return false;
  406.             }

  408.             // check consistenza risposta
  409.             if(this.debug)
  410.                 this.logger.debug("Check consistenza...");
  411.             SOAPMessage soapResponse = null;
  412.             if(this.responseMsg!=null){
  413.                 OpenSPCoop2SoapMessage soapMessageResponse = this.responseMsg.castAsSoap();
  414.                 soapResponse = soapMessageResponse.getSOAPMessage();
  415.                 if(soapMessageResponse.getSOAPBody()!=null){
  416.                     if(soapMessageResponse.hasSOAPFault() ){
  417.                         if(soapMessageResponse.getSOAPBody().getFault().getFaultString().indexOf("Premature end of file") != -1){
  418.                             // L'errore 'premature end of file' consiste solo nel fatto che una risposta non e' stata ricevuta.
  419.                             this.responseMsg = null;
  420.                         }
  421.                     }
  422.                 }
  423.             }

  425.             if(soapResponse!=null){
  426.                 // Analisi MimeType e ContentLocation della risposta
  427.                 if(soapResponse.getMimeHeaders()!=null){
  428.                     
  429.                     if(this.propertiesTrasportoRisposta==null){
  430.                         this.propertiesTrasportoRisposta = new HashMap<>();
  431.                     }
  432.                     
  433.                     Iterator<?> it = soapResponse.getMimeHeaders().getAllHeaders();
  434.                     while (it.hasNext()) {
  435.                         MimeHeader mh = (MimeHeader) it.next();
  436.                         if(mh!=null && mh.getName()!=null && mh.getValue()!=null) {
  437.                             TransportUtils.addHeader(this.propertiesTrasportoRisposta,mh.getName(),mh.getValue());
  438.                             if("content-length".equalsIgnoreCase(mh.getName())){
  439.                                 try{
  440.                                     this.contentLength = Integer.parseInt(mh.getValue());
  441.                                 }catch(Exception e){}
  442.                             }
  443.                             if("content-type".equalsIgnoreCase(mh.getName())){
  444.                                 try{
  445.                                     this.tipoRisposta = mh.getValue();
  446.                                 }catch(Exception e){}
  447.                             }
  448.                         }
  449.                     }
  450.                 }
  451.             }
  452.             
  453.             // return code
  454.             this.codice = 200;

  456.             // content length
  457.             if(this.responseMsg!=null && this.contentLength<0){
  458.                 this.contentLength =  this.responseMsg.getIncomingMessageContentLength();
  459.             }
  460.             
  461.             if(this.responseMsg!=null){
  462.                 TransportResponseContext responseContext = new TransportResponseContext(this.logger.getLogger());
  463.                 responseContext.setCodiceTrasporto(this.codice+"");
  464.                 responseContext.setContentLength(this.contentLength);
  465.                 responseContext.setHeaders(this.propertiesTrasportoRisposta);
  466.                 this.responseMsg.setTransportResponseContext(responseContext);
  467.                 
  468.                 this.messageTypeResponse = this.requestMsg.getMessageType();
  469.                 if(this.tipoRisposta==null) {
  470.                     this.tipoRisposta = this.requestMsg.getContentType();
  471.                 }
  472.             }
  473.             
  474.             if(this.isDumpBinarioRisposta()){
  475.                 if(this.responseMsg!=null){
  476.                     // Registro Debug.
  477.                     DumpByteArrayOutputStream bout = null;
  478.                     try {
  479.                         try {
  480.                             bout = new DumpByteArrayOutputStream(this.dumpBinario_soglia, this.dumpBinario_repositoryFile, this.idTransazione, 
  481.                                     TipoMessaggio.RISPOSTA_INGRESSO_DUMP_BINARIO.getValue());
  482.                             
  483.                             this.emitDiagnosticStartDumpBinarioRispostaIngresso();
  484.                             
  485.                             this.responseMsg.writeTo(bout, false);
  486.                         }finally {
  487.                             try {
  488.                                 if(bout!=null) {
  489.                                     bout.flush();
  490.                                 }
  491.                             }catch(Throwable t) {
  492.                                 // ignore
  493.                             }
  494.                             try {
  495.                                 if(bout!=null) {
  496.                                     bout.close();
  497.                                 }
  498.                             }catch(Throwable t) {
  499.                                 // ignore
  500.                             }
  501.                         }
  502.                         if(this.debug) {
  503.                             this.logger.info("Messaggio ricevuto (ContentType:"+this.tipoRisposta+") :\n"+bout.toString(),false);
  504.                         }
  505.                         
  506.                         this.dumpBinarioRispostaIngresso(bout, this.messageTypeResponse, this.propertiesTrasportoRisposta);
  507.                         
  508.                         if(this.contentLength<0){
  509.                             this.contentLength=bout.size(); // la prendo dal dump, poiche' in saaj non ho modo di agganciare il counting stream
  510.                         }
  511.                         
  512.                     }finally {
  513.                         try {
  514.                             if(bout!=null) {
  515.                                 bout.clearResources();
  516.                             }
  517.                         }catch(Throwable t) {
  518.                             this.logger.error("Release resources failed: "+t.getMessage(),t);
  519.                         }
  520.                     }
  521.                 }
  522.                 else {
  523.                     if(this.debug) {
  524.                         if(this.tipoRisposta!=null) {
  525.                             this.logger.info("Messaggio ricevuto (ContentType:"+this.tipoRisposta+") senza contenuto nell'http-reply",false);
  526.                         }
  527.                         else {
  528.                             this.logger.info("Messaggio ricevuto senza contenuto nell'http-reply",false);
  529.                         }
  530.                     }
  531.                     
  532.                     // devo registrare almeno gli header HTTP
  533.                     this.emitDiagnosticStartDumpBinarioRispostaIngresso();
  534.                     this.dumpBinarioRispostaIngresso(null, null, this.propertiesTrasportoRisposta);
  535.                 }
  536.             }
  537.             
  538.             
  539.             if(this.debug)
  540.                 this.logger.info("Gestione invio/risposta http effettuata con successo",false);
  541.             
  542.             
  543.             
  544.             
  545.             
  546.             /* ------------  PostOutRequestHandler ------------- */
  547.             this.postOutRequest();
  548.             
  549.             
  550.             
  551.             
  552.             
  553. //          /* ------------  PreInResponseHandler ------------- */
  554.             // Con connettore SAAJ non e' utilizzabile
  555. //          this.preInResponse();
  556. //          
  557. //          // Lettura risposta parametri NotifierInputStream per la risposta
  558. //          org.openspcoop.utils.io.notifier.NotifierInputStreamParams notifierInputStreamParams = null;
  559. //          if(this.preInResponseContext!=null){
  560. //              notifierInputStreamParams = this.preInResponseContext.getNotifierInputStreamParams();
  561. //          }
  562.             
  563.             
  564.             
  565.             
  566.             return true;
  567.         }  catch(Exception e){ 
  568.             this.eccezioneProcessamento = e;
  569.             String msgErrore = this.readExceptionMessageFromException(e);
  570.             if(this.generateErrorWithConnectorPrefix) {
  571.                 this.errore = "Errore avvenuto durante la consegna SOAP: "+msgErrore;
  572.             }
  573.             else {
  574.                 this.errore = msgErrore;
  575.             }
  576.             this.logger.error("Errore avvenuto durante la consegna SOAP: "+msgErrore,e);
  577.             
  578.             this.processConnectionTimeoutException(connectionTimeout, connectionTimeoutConfigurazioneGlobale, e, msgErrore);
  579.             
  580.             this.processReadTimeoutException(readConnectionTimeout, readConnectionTimeoutConfigurazioneGlobale, e, msgErrore);
  581.             
  582.             return false;
  583.         }
  584.     }

  586.     /**
  587.      * Effettua la disconnessione 
  588.      */
  589.     @Override
  590.     public void disconnect() throws ConnettoreException{
  591.         
  592.         List<Throwable> listExceptionChiusura = new ArrayList<Throwable>();
  593.         try{
  594.         
  595.             if(this.connection!=null){
  596.                 if(this.debug && this.logger!=null)
  597.                     this.logger.debug("Connection.close ...");
  598.                 try {
  599.                     this.connection.close();
  600.                 }catch(Throwable t) {
  601.                     if(this.logger!=null) {
  602.                         this.logger.debug("Chiusura socket fallita: "+t.getMessage(),t);
  603.                     }
  604.                     listExceptionChiusura.add(t);
  605.                 }
  606.             }
  607.             
  608.             // super.disconnect (Per risorse base)
  609.             try {
  610.                 super.disconnect();
  611.             }catch(Throwable t) {
  612.                 if(this.logger!=null) {
  613.                     this.logger.debug("Chiusura risorse fallita: "+t.getMessage(),t);
  614.                 }
  615.                 listExceptionChiusura.add(t);
  616.             }
  617.             
  618.         }catch(Exception e){
  619.             throw new ConnettoreException("Chiusura connessione non riuscita: "+e.getMessage(),e);
  620.         }   
  621.         
  622.         if(listExceptionChiusura!=null && !listExceptionChiusura.isEmpty()) {
  623.             org.openspcoop2.utils.UtilsMultiException multiException = new org.openspcoop2.utils.UtilsMultiException(listExceptionChiusura.toArray(new Throwable[1]));
  624.             throw new ConnettoreException("Chiusura connessione non riuscita: "+multiException.getMessage(),multiException);
  625.         }
  626.     }
  627.     
  628.     private void setRequestHeader(boolean validazioneHeaderRFC2047, String key, List<String> values, ConnettoreLogger logger, Map<String, List<String>> propertiesTrasportoDebug) throws Exception {
  629.         
  630.         if(validazioneHeaderRFC2047){
  631.             try{
  632.                 RFC2047Utilities.validHeader(key, values);
  633.                 setRequestHeader(key, values, propertiesTrasportoDebug);
  634.             }catch(UtilsException e){
  635.                 logger.error(e.getMessage(),e);
  636.             }
  637.         }
  638.         else{
  639.             setRequestHeader(key,values, propertiesTrasportoDebug);
  640.         }
  641.         
  642.     }
  643.     
  644.     @Override
  645.     protected void setRequestHeader(String key,List<String> values) throws Exception {
  646.         if(values!=null && !values.isEmpty()) {
  647.             for (String value : values) {
  648.                 this.soapRequestMessage.getMimeHeaders().addHeader(key,value);  
  649.             }
  650.         }
  651.     }
  652.     
  653. }




Created with JaCoCo 0.8.8.202204050719