ConnettoreHTTPCORE.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.InputStream;
  24. import java.net.URI;
  25. import java.net.URL;
  26. import java.util.ArrayList;
  27. import java.util.HashMap;
  28. import java.util.Iterator;
  29. import java.util.List;
  30. import java.util.Map;

  32. import javax.net.ssl.HostnameVerifier;
  33. import javax.net.ssl.SSLSocketFactory;

  35. import org.apache.commons.lang.StringUtils;
  36. import org.apache.http.Header;
  37. import org.apache.http.HeaderElement;
  38. import org.apache.http.HeaderElementIterator;
  39. import org.apache.http.HttpEntity;
  40. import org.apache.http.HttpResponse;
  41. import org.apache.http.client.HttpClient;
  42. import org.apache.http.client.config.RequestConfig;
  43. import org.apache.http.client.methods.HttpDelete;
  44. import org.apache.http.client.methods.HttpEntityEnclosingRequestBase;
  45. import org.apache.http.client.methods.HttpGet;
  46. import org.apache.http.client.methods.HttpHead;
  47. import org.apache.http.client.methods.HttpOptions;
  48. import org.apache.http.client.methods.HttpPatch;
  49. import org.apache.http.client.methods.HttpPost;
  50. import org.apache.http.client.methods.HttpRequestBase;
  51. import org.apache.http.client.methods.HttpTrace;
  52. import org.apache.http.config.Registry;
  53. import org.apache.http.config.RegistryBuilder;
  54. import org.apache.http.conn.ConnectionKeepAliveStrategy;
  55. import org.apache.http.conn.socket.ConnectionSocketFactory;
  56. import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
  57. import org.apache.http.entity.ByteArrayEntity;
  58. import org.apache.http.entity.FileEntity;
  59. import org.apache.http.entity.InputStreamEntity;
  60. import org.apache.http.impl.client.DefaultClientConnectionReuseStrategy;
  61. import org.apache.http.impl.client.HttpClientBuilder;
  62. import org.apache.http.impl.client.HttpClients;
  63. import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
  64. import org.apache.http.message.BasicHeaderElementIterator;
  65. import org.apache.http.protocol.HTTP;
  66. import org.apache.http.protocol.HttpContext;
  67. import org.apache.http.util.EntityUtils;
  68. import org.openspcoop2.core.config.ResponseCachingConfigurazione;
  69. import org.openspcoop2.core.constants.CostantiConnettori;
  70. import org.openspcoop2.core.constants.TransferLengthModes;
  71. import org.openspcoop2.core.transazioni.constants.TipoMessaggio;
  72. import org.openspcoop2.message.OpenSPCoop2RestMessage;
  73. import org.openspcoop2.message.OpenSPCoop2SoapMessage;
  74. import org.openspcoop2.message.constants.Costanti;
  75. import org.openspcoop2.message.constants.MessageType;
  76. import org.openspcoop2.message.soap.TunnelSoapUtils;
  77. import org.openspcoop2.pdd.mdb.ConsegnaContenutiApplicativi;
  78. import org.openspcoop2.utils.NameValue;
  79. import org.openspcoop2.utils.UtilsException;
  80. import org.openspcoop2.utils.date.DateManager;
  81. import org.openspcoop2.utils.io.Base64Utilities;
  82. import org.openspcoop2.utils.io.DumpByteArrayOutputStream;
  83. import org.openspcoop2.utils.transport.TransportUtils;
  84. import org.openspcoop2.utils.transport.http.HttpBodyParameters;
  85. import org.openspcoop2.utils.transport.http.HttpConstants;
  86. import org.openspcoop2.utils.transport.http.HttpRequestMethod;
  87. import org.openspcoop2.utils.transport.http.HttpUtilities;
  88. import org.openspcoop2.utils.transport.http.RFC2047Utilities;
  89. import org.openspcoop2.utils.transport.http.SSLUtilities;
  90. import org.openspcoop2.utils.transport.http.WrappedLogSSLSocketFactory;

  92. /**
  93.  * Connettore che utilizza la libreria httpcore
  94.  *
  95.  *
  96.  * @author Poli Andrea (apoli@link.it)
  97.  * @author $Author$
  98.  * @version $Rev$, $Date$
  99.  */
  100. public class ConnettoreHTTPCORE extends ConnettoreBaseHTTP {

  102.     public static final String ENDPOINT_TYPE = "httpcore";
  103.     
  104.     
  105.     private static boolean USE_POOL = true;
  106.     
  107.     private HttpEntity httpEntityResponse = null;
  108.     private HttpClient httpClient = null;
  109.         
  110.     private HttpRequestBase httpRequest;
  111.     
  112.     
  113.     /* Costruttori */
  114.     public ConnettoreHTTPCORE(){
  115.         this.connettoreHttps = false;
  116.     }
  117.     public ConnettoreHTTPCORE(boolean https){
  118.         this.connettoreHttps = https;
  119.     }
  120.     
  121.     
  122.     private static Map<String, PoolingHttpClientConnectionManager> cmMap = new HashMap<String, PoolingHttpClientConnectionManager>();
  123.     private static synchronized void initialize(String key, SSLConnectionSocketFactory sslConnectionSocketFactory){
  124.         if(!ConnettoreHTTPCORE.cmMap.containsKey(key)){
  125.                         
  126.             PoolingHttpClientConnectionManager cm = null;
  127.             if(sslConnectionSocketFactory!=null) {
  128.                 Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder
  129.                         .<ConnectionSocketFactory> create().register("https", sslConnectionSocketFactory)
  130.                         .build();
  131.                 cm = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
  132.             }
  133.             else {
  134.                 cm = new PoolingHttpClientConnectionManager();
  135.             }
  136.             // Increase max total connection to 200
  137.             cm.setMaxTotal(200);
  138.             // Increase default max connection per route to 20
  139.             cm.setDefaultMaxPerRoute(5);
  140.             // Increase max connections for localhost:80 to 50
  141.             //HttpHost localhost = new HttpHost("locahost", 80);
  142.             //cm.setMaxPerRoute(new HttpRoute(localhost), 50);
  143.              
  144.             ConnettoreHTTPCORE.cmMap.put(key, cm);
  145.         }
  146.     }
  147.     
  148.     private HttpClient buildHttpClient(ConnectionKeepAliveStrategy keepAliveStrategy, SSLSocketFactory sslSocketFactory, boolean usePool) throws UtilsException{
  149.         
  150.         HttpClientBuilder httpClientBuilder = HttpClients.custom();
  151.             
  152.         // Imposta Contesto SSL se attivo
  153.         
  154.         String key = "default";
  155.         if(this.sslContextProperties!=null){
  156.             key = this.sslContextProperties.toString();
  157.         }
  158.         
  159.         SSLConnectionSocketFactory sslConnectionSocketFactory = null;
  160.         if(this.sslContextProperties!=null && 
  161.                 (!usePool || !ConnettoreHTTPCORE.cmMap.containsKey(key))){
  162.             if(this.debug) {
  163.                 String clientCertificateConfigurated = this.sslContextProperties.getKeyStoreLocation();
  164.                 sslSocketFactory = new WrappedLogSSLSocketFactory(sslSocketFactory, 
  165.                         this.logger.getLogger(), this.logger.buildMsg(""),
  166.                         clientCertificateConfigurated);
  167.             }       
  168.             
  169.             StringBuilder bfLog = new StringBuilder();
  170.             HostnameVerifier hostnameVerifier = SSLUtilities.generateHostnameVerifier(this.sslContextProperties, bfLog, 
  171.                     this.logger.getLogger(), this.loader);
  172.             if(this.debug)
  173.                 this.logger.debug(bfLog.toString());
  174.             
  175.             if(hostnameVerifier==null) {
  176.                 hostnameVerifier = SSLConnectionSocketFactory.getDefaultHostnameVerifier();
  177.             }
  178.             sslConnectionSocketFactory = new SSLConnectionSocketFactory(sslSocketFactory, hostnameVerifier);
  179.         }
  180.         
  181.         if(usePool) {
  182.                         
  183.             // Caso con pool
  184.             if(!ConnettoreHTTPCORE.cmMap.containsKey(key)){
  185.                 ConnettoreHTTPCORE.initialize(key, sslConnectionSocketFactory);
  186.             }
  187.             
  188.             PoolingHttpClientConnectionManager cm = ConnettoreHTTPCORE.cmMap.get(key);
  189.             
  190.             //System.out.println("-----GET CONNECTION [START] ----");
  191.             //System.out.println("PRIMA CLOSE AVAILABLE["+cm.getTotalStats().getAvailable()+"] LEASED["
  192.             //      +cm.getTotalStats().getLeased()+"] MAX["+cm.getTotalStats().getMax()+"] PENDING["+cm.getTotalStats().getPending()+"]");
  193.             // BLOCKED ConnettoreHTTPCORE.cm.closeExpiredConnections();
  194.             // BLOCKED ConnettoreHTTPCORE.cm.closeIdleConnections(30, java.util.concurrent.TimeUnit.SECONDS);
  195.             //System.out.println("DOPO CLOSE AVAILABLE["+cm.getTotalStats().getAvailable()+"] LEASED["
  196.             //      +cm.getTotalStats().getLeased()+"] MAX["+cm.getTotalStats().getMax()+"] PENDING["+cm.getTotalStats().getPending()+"]");
  197.             httpClientBuilder.setConnectionManager(cm);
  198.         }
  199.         else {
  200.             if(sslConnectionSocketFactory!=null) {
  201.                 httpClientBuilder.setSSLSocketFactory(sslConnectionSocketFactory);      
  202.             }
  203.         }
  204.         
  205.         DefaultClientConnectionReuseStrategy defaultClientConnectionReuseStrategy = new DefaultClientConnectionReuseStrategy();
  206.         httpClientBuilder.setConnectionReuseStrategy(defaultClientConnectionReuseStrategy);
  207.         
  208.         if(keepAliveStrategy!=null){
  209.             httpClientBuilder.setKeepAliveStrategy(keepAliveStrategy);
  210.         }
  211.                 
  212.         //System.out.println("PRESA LA CONNESSIONE AVAILABLE["+cm.getTotalStats().getAvailable()+"] LEASED["
  213.         //      +cm.getTotalStats().getLeased()+"] MAX["+cm.getTotalStats().getMax()+"] PENDING["+cm.getTotalStats().getPending()+"]");
  214.         //System.out.println("-----GET CONNECTION [END] ----");
  215.         
  216.         return httpClientBuilder.build();
  217.     }
  218.     
  219.     
  220.     @Override
  221.     protected boolean initializePreSend(ResponseCachingConfigurazione responseCachingConfig, ConnettoreMsg request) {
  222.         
  223.         if(this.initialize(request, true, responseCachingConfig)==false){
  224.             return false;
  225.         }
  226.         
  227.         return true;
  228.         
  229.     }
  230.     
  231.     @Override
  232.     protected boolean send(ConnettoreMsg request) {
  233.         
  234.         // HTTPS
  235.         try{
  236.             this.setSSLContext();
  237.         }catch(Exception e){
  238.             this.eccezioneProcessamento = e;
  239.             this.logger.error("[HTTPS error]"+ this.readExceptionMessageFromException(e),e);
  240.             this.errore = "[HTTPS error]"+ this.readExceptionMessageFromException(e);
  241.             return false;
  242.         }
  243.         
  244.         int connectionTimeout = -1;
  245.         boolean connectionTimeoutConfigurazioneGlobale = true;
  246.         int readConnectionTimeout = -1;
  247.         boolean readConnectionTimeoutConfigurazioneGlobale = true;
  248.         try{
  249.             
  250.             // Creazione URL
  251.             if(this.debug)
  252.                 this.logger.debug("Creazione URL...");
  253.             this.buildLocation();       
  254.             if(this.debug)
  255.                 this.logger.debug("Creazione URL ["+this.location+"]...");
  256.             URL url = new URL( this.location ); 
  257.             
  258.             
  259.             // Keep-alive
  260.             ConnectionKeepAliveStrategy keepAliveStrategy = null; //new ConnectionKeepAliveStrategyCustom();
  261.             
  262.             
  263.             
  264.             // Collezione header di trasporto per dump
  265.             Map<String, List<String>> propertiesTrasportoDebug = null;
  266.             if(this.isDumpBinarioRichiesta()) {
  267.                 propertiesTrasportoDebug = new HashMap<>();
  268.             }

  270.             
  271.             // Creazione Connessione
  272.             if(this.debug)
  273.                 this.logger.info("Creazione connessione alla URL ["+this.location+"]...",false);
  274.             this.httpClient = buildHttpClient(keepAliveStrategy, buildSSLContextFactory(), ConnettoreHTTPCORE.USE_POOL);
  275.             
  276.             // HttpMethod
  277.             if(this.httpMethod==null){
  278.                 throw new Exception("HttpRequestMethod non definito");
  279.             }
  280.             this.httpRequest = null;
  281.             switch (this.httpMethod) {
  282.                 case GET:
  283.                     this.httpRequest = new HttpGet(url.toString());
  284.                     break;
  285.                 case DELETE:
  286.                     this.httpRequest = new HttpDelete(url.toString());
  287.                     break;
  288.                 case HEAD:
  289.                     this.httpRequest = new HttpHead(url.toString());
  290.                     break;
  291.                 case POST:
  292.                     this.httpRequest = new HttpPost(url.toString());
  293.                     break;
  294.                 case PUT:
  295.                     this.httpRequest = new HttpPost(url.toString());
  296.                     break;
  297.                 case OPTIONS:
  298.                     this.httpRequest = new HttpOptions(url.toString());
  299.                     break;
  300.                 case TRACE:
  301.                     this.httpRequest = new HttpTrace(url.toString());
  302.                     break;
  303.                 case PATCH:
  304.                     this.httpRequest = new HttpPatch(url.toString());
  305.                     break;  
  306.                 default:
  307.                     this.httpRequest = new CustomHttpEntity(this.httpMethod, url.toString());
  308.                     break;
  309.             }
  310.             if(this.httpMethod==null){
  311.                 throw new Exception("HttpRequest non definito ?");
  312.             }
  313.             RequestConfig.Builder requestConfigBuilder = RequestConfig.custom();
  314.             
  315.             
  316.             
  317.             // Tipologia di servizio
  318.             OpenSPCoop2SoapMessage soapMessageRequest = null;
  319.             MessageType requestMessageType = this.requestMsg.getMessageType();
  320.             if(this.debug)
  321.                 this.logger.debug("Tipologia Servizio: "+this.requestMsg.getServiceBinding());
  322.             if(this.isSoap){
  323.                 soapMessageRequest = this.requestMsg.castAsSoap();
  324.             }
  325.             
  326.             
  327.             
  328.             // Alcune implementazioni richiedono di aggiornare il Content-Type
  329.             this.requestMsg.updateContentType();
  330.             
  331.                         
  332.             
  333.             // Impostazione Content-Type della Spedizione su HTTP
  334.             
  335.             if(this.debug)
  336.                 this.logger.debug("Impostazione content type...");
  337.             String contentTypeRichiesta = null;
  338.             if(this.isSoap){
  339.                 if(this.sbustamentoSoap && soapMessageRequest.countAttachments()>0 && TunnelSoapUtils.isTunnelOpenSPCoopSoap(soapMessageRequest)){
  340.                     contentTypeRichiesta = TunnelSoapUtils.getContentTypeTunnelOpenSPCoopSoap(soapMessageRequest.getSOAPBody());
  341.                 }else{
  342.                     contentTypeRichiesta = this.requestMsg.getContentType();
  343.                 }
  344.                 if(contentTypeRichiesta==null){
  345.                     throw new Exception("Content-Type del messaggio da spedire non definito");
  346.                 }
  347.             }
  348.             else{
  349.                 contentTypeRichiesta = this.requestMsg.getContentType();
  350.                 // Content-Type non obbligatorio in REST
  351.             }
  352.             if(this.debug)
  353.                 this.logger.info("Impostazione http Content-Type ["+contentTypeRichiesta+"]",false);
  354.             if(contentTypeRichiesta!=null){
  355.                 this.setRequestHeader(HttpConstants.CONTENT_TYPE, contentTypeRichiesta, propertiesTrasportoDebug);
  356.             }
  357.             
  358.             
  359.             
  360.             // Impostazione transfer-length
  361.             if(this.debug)
  362.                 this.logger.debug("Impostazione transfer-length...");
  363.             boolean transferEncodingChunked = false;
  364.             TransferLengthModes tlm = null;
  365.             int chunkLength = -1;
  366.             if(ConsegnaContenutiApplicativi.ID_MODULO.equals(this.idModulo)){
  367.                 tlm = this.openspcoopProperties.getTransferLengthModes_consegnaContenutiApplicativi();
  368.                 chunkLength = this.openspcoopProperties.getChunkLength_consegnaContenutiApplicativi();
  369.             }
  370.             else{
  371.                 // InoltroBuste e InoltroRisposte
  372.                 tlm = this.openspcoopProperties.getTransferLengthModes_inoltroBuste();
  373.                 chunkLength = this.openspcoopProperties.getChunkLength_inoltroBuste();
  374.             }
  375.             transferEncodingChunked = TransferLengthModes.TRANSFER_ENCODING_CHUNKED.equals(tlm);
  376.             if(transferEncodingChunked){
  377.                 //this.httpConn.setChunkedStreamingMode(chunkLength);
  378.             }
  379.             if(this.debug)
  380.                 this.logger.info("Impostazione transfer-length effettuata (chunkLength:"+chunkLength+"): "+tlm,false);
  381.             
  382.             
  383.             
  384.             // Impostazione timeout
  385.             if(this.debug)
  386.                 this.logger.debug("Impostazione timeout...");
  387.             if(this.properties.get(CostantiConnettori.CONNETTORE_CONNECTION_TIMEOUT)!=null){
  388.                 try{
  389.                     connectionTimeout = Integer.parseInt(this.properties.get(CostantiConnettori.CONNETTORE_CONNECTION_TIMEOUT));
  390.                     connectionTimeoutConfigurazioneGlobale = this.properties.containsKey(CostantiConnettori.CONNETTORE_CONNECTION_TIMEOUT_GLOBALE);
  391.                 }catch(Exception e){
  392.                     this.logger.error("Parametro '"+CostantiConnettori.CONNETTORE_CONNECTION_TIMEOUT+"' errato",e);
  393.                 }
  394.             }
  395.             if(connectionTimeout==-1){
  396.                 connectionTimeout = HttpUtilities.HTTP_CONNECTION_TIMEOUT;
  397.             }
  398.             if(this.properties.get(CostantiConnettori.CONNETTORE_READ_CONNECTION_TIMEOUT)!=null){
  399.                 try{
  400.                     readConnectionTimeout = Integer.parseInt(this.properties.get(CostantiConnettori.CONNETTORE_READ_CONNECTION_TIMEOUT));
  401.                     readConnectionTimeoutConfigurazioneGlobale = this.properties.containsKey(CostantiConnettori.CONNETTORE_READ_CONNECTION_TIMEOUT_GLOBALE);
  402.                 }catch(Exception e){
  403.                     this.logger.error("Parametro '"+CostantiConnettori.CONNETTORE_READ_CONNECTION_TIMEOUT+"' errato",e);
  404.                 }
  405.             }
  406.             if(readConnectionTimeout==-1){
  407.                 readConnectionTimeout = HttpUtilities.HTTP_READ_CONNECTION_TIMEOUT;
  408.             }
  409.             if(this.debug)
  410.                 this.logger.info("Impostazione http timeout CT["+connectionTimeout+"] RT["+readConnectionTimeout+"]",false);
  411.             requestConfigBuilder.setConnectionRequestTimeout(connectionTimeout);
  412.             requestConfigBuilder.setConnectTimeout(connectionTimeout);
  413.             requestConfigBuilder.setSocketTimeout(readConnectionTimeout);
  414.             


  417.             
  418.             
  419.             
  420.             // Gestione automatica del redirect
  421.             //this.httpConn.setInstanceFollowRedirects(true); 
  422.             
  423.             
  424.                 
  425.             // Authentication BASIC
  426.             if(this.debug)
  427.                 this.logger.debug("Impostazione autenticazione...");
  428.             String user = null;
  429.             String password = null;
  430.             if(this.credenziali!=null){
  431.                 user = this.credenziali.getUser();
  432.                 password = this.credenziali.getPassword();
  433.             }else{
  434.                 user = this.properties.get(CostantiConnettori.CONNETTORE_USERNAME);
  435.                 password = this.properties.get(CostantiConnettori.CONNETTORE_PASSWORD);
  436.             }
  437.             if(user!=null && password!=null){
  438.                 String authentication = user + ":" + password;
  439.                 authentication = HttpConstants.AUTHORIZATION_PREFIX_BASIC + Base64Utilities.encodeAsString(authentication.getBytes());
  440.                 this.setRequestHeader(HttpConstants.AUTHORIZATION,authentication, propertiesTrasportoDebug);
  441.                 if(this.debug)
  442.                     this.logger.info("Impostazione autenticazione (username:"+user+" password:"+password+") ["+authentication+"]",false);
  443.             }
  444.             
  445.             
  446.             
  447.             // Authentication Token
  448.             NameValue nv = this.getTokenHeader();
  449.             if(nv!=null) {
  450.                 if(this.requestMsg!=null && this.requestMsg.getTransportRequestContext()!=null) {
  451.                     this.requestMsg.getTransportRequestContext().removeHeader(nv.getName()); // Fix: senno sovrascriveva il vecchio token
  452.                 }
  453.                 this.setRequestHeader(nv.getName(),nv.getValue(), propertiesTrasportoDebug);
  454.                 if(this.debug)
  455.                     this.logger.info("Impostazione autenticazione token (header-name '"+nv.getName()+"' value '"+nv.getValue()+"')",false);
  456.             }
  457.             
  458.             
  459.             
  460.             
  461.             // Authentication Api Key
  462.             String apiKey = this.properties.get(CostantiConnettori.CONNETTORE_APIKEY);
  463.             if(apiKey!=null && StringUtils.isNotEmpty(apiKey)){
  464.                 String apiKeyHeader = this.properties.get(CostantiConnettori.CONNETTORE_APIKEY_HEADER);
  465.                 if(apiKeyHeader==null || StringUtils.isEmpty(apiKeyHeader)) {
  466.                     apiKeyHeader = CostantiConnettori.DEFAULT_HEADER_API_KEY;
  467.                 }
  468.                 this.setRequestHeader(apiKeyHeader,apiKey, propertiesTrasportoDebug);
  469.                 if(this.debug)
  470.                     this.logger.info("Impostazione autenticazione api key ["+apiKeyHeader+"]=["+apiKey+"]",false);
  471.                 
  472.                 String appId = this.properties.get(CostantiConnettori.CONNETTORE_APIKEY_APPID);
  473.                 if(appId!=null && StringUtils.isNotEmpty(appId)){
  474.                     String appIdHeader = this.properties.get(CostantiConnettori.CONNETTORE_APIKEY_APPID_HEADER);
  475.                     if(appIdHeader==null || StringUtils.isEmpty(appIdHeader)) {
  476.                         appIdHeader = CostantiConnettori.DEFAULT_HEADER_APP_ID;
  477.                     }
  478.                     this.setRequestHeader(appIdHeader,appId, propertiesTrasportoDebug);
  479.                     if(this.debug)
  480.                         this.logger.info("Impostazione autenticazione api key (app id) ["+appIdHeader+"]=["+appId+"]",false);
  481.                 }
  482.             }
  483.             
  484.             
  485.             
  486.             
  487.             // ForwardProxy
  488.             if(this.forwardProxy_headerName!=null && this.forwardProxy_headerValue!=null) {
  489.                 if(this.requestMsg!=null && this.requestMsg.getTransportRequestContext()!=null) {
  490.                     this.requestMsg.getTransportRequestContext().removeHeader(this.forwardProxy_headerName); // Fix: senno sovrascriveva il vecchio token
  491.                 }
  492.                 setRequestHeader(this.forwardProxy_headerName,this.forwardProxy_headerValue, propertiesTrasportoDebug);
  493.                 if(this.debug)
  494.                     this.logger.info("Impostazione ForwardProxy (header-name '"+this.forwardProxy_headerName+"' value '"+this.forwardProxy_headerValue+"')",false);
  495.             }

  497.             
  498.             
  499.             // Impostazione Proprieta del trasporto
  500.             if(this.debug)
  501.                 this.logger.debug("Impostazione header di trasporto...");
  502.             this.forwardHttpRequestHeader();
  503.             if(this.propertiesTrasporto != null){
  504.                 Iterator<String> keys = this.propertiesTrasporto.keySet().iterator();
  505.                 while (keys.hasNext()) {
  506.                     String key = (String) keys.next();
  507.                     List<String> values = this.propertiesTrasporto.get(key);
  508.                     if(this.debug) {
  509.                         if(values!=null && !values.isEmpty()) {
  510.                             for (String value : values) {
  511.                                 this.logger.info("Set Transport Header ["+key+"]=["+value+"]",false);
  512.                             }
  513.                         }
  514.                     }
  515.                     
  516.                     if(this.encodingRFC2047){
  517.                         List<String> valuesEncoded = new ArrayList<>();
  518.                         if(values!=null && !values.isEmpty()) {
  519.                             for (String value : values) {
  520.                                 if(RFC2047Utilities.isAllCharactersInCharset(value, this.charsetRFC2047)==false){
  521.                                     String encoded = RFC2047Utilities.encode(new String(value), this.charsetRFC2047, this.encodingAlgorithmRFC2047);
  522.                                     //System.out.println("@@@@ CODIFICA ["+value+"] in ["+encoded+"]");
  523.                                     if(this.debug)
  524.                                         this.logger.info("RFC2047 Encoded value in ["+encoded+"] (charset:"+this.charsetRFC2047+" encoding-algorithm:"+this.encodingAlgorithmRFC2047+")",false);
  525.                                     valuesEncoded.add(encoded);
  526.                                 }
  527.                                 else{
  528.                                     valuesEncoded.add(value);
  529.                                 }
  530.                             }
  531.                         }
  532.                         setRequestHeader(this.validazioneHeaderRFC2047, key, valuesEncoded, this.logger, propertiesTrasportoDebug);
  533.                     }
  534.                     else{
  535.                         this.setRequestHeader(this.validazioneHeaderRFC2047, key, values, this.logger, propertiesTrasportoDebug);
  536.                     }
  537.                 }
  538.             }
  539.             
  540.             
  541.             
  542.             
  543.             // Aggiunga del SoapAction Header in caso di richiesta SOAP
  544.             // spostato sotto il forwardHeader per consentire alle trasformazioni di modificarla
  545.             if(this.isSoap && this.sbustamentoSoap == false){
  546.                 if(this.debug)
  547.                     this.logger.debug("Impostazione soap action...");
  548.                 boolean existsTransportProperties = false;
  549.                 if(TransportUtils.containsKey(this.propertiesTrasporto, Costanti.SOAP11_MANDATORY_HEADER_HTTP_SOAP_ACTION)){
  550.                     this.soapAction = TransportUtils.getFirstValue(this.propertiesTrasporto, Costanti.SOAP11_MANDATORY_HEADER_HTTP_SOAP_ACTION);
  551.                     existsTransportProperties = (this.soapAction!=null);
  552.                 }
  553.                 if(!existsTransportProperties) {
  554.                     this.soapAction = soapMessageRequest.getSoapAction();
  555.                 }
  556.                 if(this.soapAction==null){
  557.                     this.soapAction="\"OpenSPCoop\"";
  558.                 }
  559.                 if(MessageType.SOAP_11.equals(this.requestMsg.getMessageType()) && !existsTransportProperties){
  560.                     // NOTA non quotare la soap action, per mantenere la trasparenza della PdD
  561.                     this.setRequestHeader(Costanti.SOAP11_MANDATORY_HEADER_HTTP_SOAP_ACTION,this.soapAction, propertiesTrasportoDebug);
  562.                 }
  563.                 if(this.debug)
  564.                     this.logger.info("SOAP Action inviata ["+this.soapAction+"]",false);
  565.             }
  566.             
  567.             
  568.             
  569.             
  570.             // Impostazione Metodo
  571.             HttpBodyParameters httpBody = new  HttpBodyParameters(this.httpMethod, contentTypeRichiesta);
  572.             
  573.             
  574.             
  575.             // Preparazione messaggio da spedire
  576.             // Spedizione byte
  577.             if(httpBody.isDoOutput()){
  578.                 if(this.debug)
  579.                     this.logger.debug("Spedizione byte...");
  580.                 boolean hasContentRestBuilded = false;
  581.                 boolean hasContentRest = false;
  582.                 OpenSPCoop2RestMessage<?> restMessage = null;
  583.                 if(this.isRest) {
  584.                     restMessage = this.requestMsg.castAsRest();
  585.                     hasContentRest = restMessage.hasContent();
  586.                     hasContentRestBuilded = restMessage.isContentBuilded();
  587.                 }
  588.                 if(this.isDumpBinarioRichiesta() || this.isSoap || hasContentRestBuilded) {
  589.                     DumpByteArrayOutputStream bout = new DumpByteArrayOutputStream(this.dumpBinario_soglia, this.dumpBinario_repositoryFile, this.idTransazione, 
  590.                             TipoMessaggio.RICHIESTA_USCITA_DUMP_BINARIO.getValue());
  591.                     try {
  592.                         this.emitDiagnosticStartDumpBinarioRichiestaUscita();
  593.                         
  594.                         if(this.isSoap && this.sbustamentoSoap){
  595.                             if(this.debug)
  596.                                 this.logger.debug("Sbustamento...");
  597.                             TunnelSoapUtils.sbustamentoMessaggio(soapMessageRequest,bout);
  598.                         }else{
  599.                             this.requestMsg.writeTo(bout, true);
  600.                         }
  601.                         bout.flush();
  602.                         bout.close();
  603.                         if(this.isDumpBinarioRichiesta()) {
  604.                             this.dumpBinarioRichiestaUscita(bout, requestMessageType, contentTypeRichiesta, this.location, propertiesTrasportoDebug);
  605.                         }
  606.                         
  607.                         HttpEntity httpEntity = null;
  608.                         if(bout.isSerializedOnFileSystem()) {
  609.                             httpEntity = new FileEntity(bout.getSerializedFile());
  610.                         }
  611.                         else {
  612.                             httpEntity = new ByteArrayEntity(bout.toByteArray());
  613.                         }
  614.                         if(this.httpRequest instanceof HttpEntityEnclosingRequestBase){
  615.                             ((HttpEntityEnclosingRequestBase)this.httpRequest).setEntity(httpEntity);
  616.                         }
  617.                         else{
  618.                             throw new Exception("Tipo ["+this.httpRequest.getClass().getName()+"] non utilizzabile per una richiesta di tipo ["+this.httpMethod+"]");
  619.                         }
  620.                     }finally {
  621.                         try {
  622.                             bout.clearResources();
  623.                         }catch(Throwable t) {
  624.                             this.logger.error("Release resources failed: "+t.getMessage(),t);
  625.                         }
  626.                     }
  627.                 }
  628.                 else {
  629.                     // Siamo per forza rest con contenuto non costruito
  630.                     if(hasContentRest) {
  631.                         InputStream isRequest = this.requestMsg.castAsRest().getInputStream();
  632.                         HttpEntity httpEntity = new InputStreamEntity(isRequest);
  633.                         if(this.httpRequest instanceof HttpEntityEnclosingRequestBase){
  634.                             ((HttpEntityEnclosingRequestBase)this.httpRequest).setEntity(httpEntity);
  635.                         }
  636.                         else{
  637.                             throw new Exception("Tipo ["+this.httpRequest.getClass().getName()+"] non utilizzabile per una richiesta di tipo ["+this.httpMethod+"]");
  638.                         }
  639.                     }
  640.                 }
  641.             }
  642.             else {
  643.                 if(this.isDumpBinarioRichiesta()) {
  644.                     // devo registrare almeno gli header HTTP
  645.                     this.emitDiagnosticStartDumpBinarioRichiestaUscita();
  646.                     this.dumpBinarioRichiestaUscita(null, null, null, this.location, propertiesTrasportoDebug);
  647.                 }
  648.             }
  649.             
  650.             
  651.             // Imposto Configurazione
  652.             this.httpRequest.setConfig(requestConfigBuilder.build());
  653.             
  654.             
  655.             
  656.             // Spedizione byte
  657.             if(this.debug)
  658.                 this.logger.debug("Spedizione byte...");
  659.             // Eseguo la richiesta e prendo la risposta
  660.             HttpResponse httpResponse = this.httpClient.execute(this.httpRequest);
  661.             
  662.             this.dataRichiestaInoltrata = DateManager.getDate();
  663.             
  664.             this.httpEntityResponse = httpResponse.getEntity();
  665.             
  666.             
  667.             
  668.             if(this.debug)
  669.                 this.logger.debug("Analisi risposta...");
  670.             Header [] hdrRisposta = httpResponse.getAllHeaders();
  671.             Map<String, List<String>> mapHeaderHttpResponse = new HashMap<>();
  672.             if(hdrRisposta!=null){
  673.                 for (int i = 0; i < hdrRisposta.length; i++) {
  674.                     
  675.                     String key = null;
  676.                     String value = null;
  677.                     
  678.                     if(hdrRisposta[i].getName()==null){
  679.                         // Check per evitare la coppia che ha come chiave null e come valore HTTP OK 200
  680.                         if(this.debug)
  681.                             this.logger.debug("HTTP risposta ["+HttpConstants.RETURN_CODE+"] ["+hdrRisposta[i].getValue()+"]...");
  682.                         key = HttpConstants.RETURN_CODE;
  683.                         value = hdrRisposta[i].getValue();
  684.                     }
  685.                     else{
  686.                         if(this.debug)
  687.                             this.logger.debug("HTTP risposta ["+hdrRisposta[i].getName()+"] ["+hdrRisposta[i].getValue()+"]...");
  688.                         key = hdrRisposta[i].getName();
  689.                         value = hdrRisposta[i].getValue();
  690.                     }
  691.                     
  692.                     TransportUtils.addHeader(this.propertiesTrasportoRisposta, key, value);
  693.                     
  694.                     List<String> list = null;
  695.                     if(mapHeaderHttpResponse.containsKey(key)) {
  696.                         list = mapHeaderHttpResponse.get(key);
  697.                     }
  698.                     if(list==null) {
  699.                         list = new ArrayList<>();
  700.                         mapHeaderHttpResponse.put(key, list);
  701.                     }
  702.                     list.add(value);
  703.                 }
  704.             }
  705.             
  706.             this.tipoRisposta = TransportUtils.getObjectAsString(mapHeaderHttpResponse, HttpConstants.CONTENT_TYPE);
  707.             
  708.             String contentLengthHdr = TransportUtils.getObjectAsString(mapHeaderHttpResponse, HttpConstants.CONTENT_LENGTH);
  709.             if(contentLengthHdr!=null){
  710.                 this.contentLength = Long.parseLong(contentLengthHdr);
  711.             }
  712.             else {
  713.                 if(this.httpEntityResponse.getContentLength()>0){
  714.                     this.contentLength = this.httpEntityResponse.getContentLength();
  715.                 }
  716.             }
  717.             
  718.             
  719.             //System.out.println("TIPO RISPOSTA["+tipoRisposta+"] LOCATION["+locationRisposta+"]");
  720.             
  721.             // Parametri di imbustamento
  722.             if(this.isSoap){
  723.                 if("true".equals(TransportUtils.getObjectAsString(mapHeaderHttpResponse, this.openspcoopProperties.getTunnelSOAPKeyWord_headerTrasporto()))){
  724.                     this.imbustamentoConAttachment = true;
  725.                 }
  726.                 this.mimeTypeAttachment = TransportUtils.getObjectAsString(mapHeaderHttpResponse, this.openspcoopProperties.getTunnelSOAPKeyWordMimeType_headerTrasporto());
  727.                 if(this.mimeTypeAttachment==null)
  728.                     this.mimeTypeAttachment = HttpConstants.CONTENT_TYPE_OPENSPCOOP2_TUNNEL_SOAP;
  729.                 //System.out.println("IMB["+imbustamentoConAttachment+"] MIME["+mimeTypeAttachment+"]");
  730.             }

  732.             // Ricezione Risposta
  733.             if(this.debug)
  734.                 this.logger.debug("Analisi risposta input stream e risultato http...");
  735.             this.initConfigurationAcceptOnlyReturnCode_202_200();
  736.             
  737.             this.codice = httpResponse.getStatusLine().getStatusCode();
  738.             this.resultHTTPMessage = httpResponse.getStatusLine().getReasonPhrase();
  739.             
  740.             if(this.codice<300) {
  741.                 if(this.isSoap && this.acceptOnlyReturnCode_202_200){
  742.                     if(this.codice!=200 && this.codice!=202){
  743.                         throw new Exception("Return code ["+this.codice+"] non consentito dal WS-I Basic Profile (http://www.ws-i.org/Profiles/BasicProfile-1.1-2004-08-24.html#HTTP_Success_Status_Codes)");
  744.                     }
  745.                 }
  746.                 if(httpBody.isDoInput()){
  747.                     this.isResponse = this.httpEntityResponse.getContent();
  748.                 }
  749.             }else{
  750.                 this.isResponse = this.httpEntityResponse.getContent();
  751.             }
  752.             
  753.             
  754.             
  755.                         
  756.             
  757.             
  758.             
  759.             /* ------------  PostOutRequestHandler ------------- */
  760.             this.postOutRequest();
  761.             
  762.             
  763.             
  764.             
  765.             /* ------------  PreInResponseHandler ------------- */
  766.             this.preInResponse();
  767.             
  768.             // Lettura risposta parametri NotifierInputStream per la risposta
  769.             this.notifierInputStreamParams = null;
  770.             if(this.preInResponseContext!=null){
  771.                 this.notifierInputStreamParams = this.preInResponseContext.getNotifierInputStreamParams();
  772.             }
  773.             
  774.             
  775.             
  776.             /* ------------  Gestione Risposta ------------- */
  777.             
  778.             this.normalizeInputStreamResponse(readConnectionTimeout, readConnectionTimeoutConfigurazioneGlobale);
  779.             
  780.             this.initCheckContentTypeConfiguration();
  781.             
  782.             if(this.isDumpBinarioRisposta()){
  783.                 if(!this.dumpResponse(this.propertiesTrasportoRisposta)) {
  784.                     return false;
  785.                 }
  786.             }
  787.                     
  788.             if(this.isRest){
  789.                 
  790.                 if(this.doRestResponse()==false){
  791.                     return false;
  792.                 }
  793.                 
  794.             }
  795.             else{
  796.             
  797.                 if(this.doSoapResponse()==false){
  798.                     return false;
  799.                 }
  800.                 
  801.             }
  802.             
  803.             if(this.debug)
  804.                 this.logger.info("Gestione invio/risposta http effettuata con successo",false);
  805.             
  806.             return true;            
  807.                         
  808.         }  catch(Exception e){ 
  809.             this.eccezioneProcessamento = e;
  810.             String msgErrore = this.readExceptionMessageFromException(e);
  811.             if(this.generateErrorWithConnectorPrefix) {
  812.                 this.errore = "Errore avvenuto durante la consegna HTTP: "+msgErrore;
  813.             }
  814.             else {
  815.                 this.errore = msgErrore;
  816.             }
  817.             this.logger.error("Errore avvenuto durante la consegna HTTP: "+msgErrore,e);
  818.             
  819.             this.processConnectionTimeoutException(connectionTimeout, connectionTimeoutConfigurazioneGlobale, e, msgErrore);
  820.             
  821.             this.processReadTimeoutException(readConnectionTimeout, readConnectionTimeoutConfigurazioneGlobale, e, msgErrore);
  822.             
  823.             return false;
  824.         } 

  826.     }

  828.     
  829.     @Override
  830.     public void disconnect() throws ConnettoreException{
  831.         List<Throwable> listExceptionChiusura = new ArrayList<Throwable>();
  832.         try{
  833.             // Gestione finale della connessione            
  834.             //System.out.println("CHECK CLOSE STREAM...");
  835.             if(this.isResponse!=null){
  836.                 if(this.debug && this.logger!=null)
  837.                     this.logger.debug("Chiusura socket...");
  838.                 //System.out.println("CLOSE STREAM...");
  839.                 this.isResponse.close();
  840.                 //System.out.println("CLOSE STREAM");
  841.             }               
  842.         }
  843.         catch(Throwable t) {
  844.             if(this.logger!=null) {
  845.                 this.logger.debug("Chiusura socket fallita: "+t.getMessage(),t);
  846.             }
  847.             listExceptionChiusura.add(t);
  848.         }
  849.         try{
  850.             // Gestione finale della connessione
  851.             //System.out.println("CHECK ENTITY...");
  852.             if(this.httpEntityResponse!=null){
  853.                 if(this.debug && this.logger!=null)
  854.                     this.logger.debug("Chiusura httpEntityResponse...");
  855.                 //System.out.println("CLOSE ENTITY...");
  856.                 EntityUtils.consume(this.httpEntityResponse);
  857.                 //System.out.println("CLOSE ENTITY");
  858.             }
  859.             
  860.             if(this.httpEntityResponse!=null){
  861.                 
  862.             }
  863.                 
  864.         }catch(Throwable t) {
  865.             if(this.logger!=null) {
  866.                 this.logger.debug("Chiusura connessione fallita: "+t.getMessage(),t);
  867.             }
  868.             listExceptionChiusura.add(t);
  869.         }
  870.         try{
  871.             // super.disconnect (Per risorse base)
  872.             super.disconnect();
  873.         }catch(Throwable t) {
  874.             if(this.logger!=null) {
  875.                 this.logger.debug("Chiusura risorse fallita: "+t.getMessage(),t);
  876.             }
  877.             listExceptionChiusura.add(t);
  878.         }
  879.         
  880.         if(listExceptionChiusura!=null && !listExceptionChiusura.isEmpty()) {
  881.             org.openspcoop2.utils.UtilsMultiException multiException = new org.openspcoop2.utils.UtilsMultiException(listExceptionChiusura.toArray(new Throwable[1]));
  882.             throw new ConnettoreException("Chiusura connessione non riuscita: "+multiException.getMessage(),multiException);
  883.         }
  884.     }
  885.         
  886.     
  887.     
  888.     /**
  889.      * Ritorna l'informazione su dove il connettore sta spedendo il messaggio
  890.      * 
  891.      * @return location di inoltro del messaggio
  892.      */
  893.     @Override
  894.     public String getLocation(){
  895.         if(this.location==null){
  896.             // può darsi che per un errore non sia ancora stata inizializzata la location
  897.             try{
  898.                 this.buildLocation();
  899.             }catch(Throwable t){}
  900.         }
  901.         if(this.location!=null){
  902.             String l = new String(this.location);
  903. //          if(this.forwardProxy!=null && this.forwardProxy.isEnabled()) {
  904. //              l = l+" [govway-proxy]";
  905. //          }
  906.             return l;
  907.         }
  908.         return null;
  909.     }
  910.     private void buildLocation() throws ConnettoreException {
  911.         this.location = TransportUtils.getObjectAsString(this.properties,CostantiConnettori.CONNETTORE_LOCATION);   
  912.         NameValue nv = this.getTokenQueryParameter();
  913.         if(nv!=null) {
  914.             if(this.requestMsg!=null && this.requestMsg.getTransportRequestContext()!=null) {
  915.                 this.requestMsg.getTransportRequestContext().removeParameter(nv.getName()); // Fix: senno sovrascriveva il vecchio token
  916.             }
  917.             if(this.propertiesUrlBased==null) {
  918.                 this.propertiesUrlBased = new HashMap<>();
  919.             }
  920.             TransportUtils.setParameter(this.propertiesUrlBased, nv.getName(), nv.getValue());
  921.         }
  922.         this.location = ConnettoreUtils.buildLocationWithURLBasedParameter(this.logger!=null ? this.logger.getLogger() : null, this.requestMsg, 
  923.                 ConnettoreHTTPCORE.ENDPOINT_TYPE, 
  924.                 this.propertiesUrlBased, this.location,
  925.                 this.getProtocolFactory(), this.idModulo);
  926.         
  927.         this.updateLocation_forwardProxy(this.location);
  928.     }
  929.     
  930.     
  931.     
  932.     private void setRequestHeader(boolean validazioneHeaderRFC2047, String key, List<String> values, ConnettoreLogger logger, Map<String, List<String>> propertiesTrasportoDebug) throws Exception {
  933.         if(validazioneHeaderRFC2047){
  934.             try{
  935.                 RFC2047Utilities.validHeader(key, values);
  936.                 setRequestHeader(key, values, propertiesTrasportoDebug);
  937.             }catch(UtilsException e){
  938.                 logger.error(e.getMessage(),e);
  939.             }
  940.         }
  941.         else{
  942.             setRequestHeader(key, values, propertiesTrasportoDebug);
  943.         }
  944.         
  945.     }
  946.     
  947.     @Override
  948.     protected void setRequestHeader(String key, List<String> values) throws Exception {
  949.         if(values!=null && !values.isEmpty()) {
  950.             for (String value : values) {
  951.                 this.httpRequest.addHeader(key,value);      
  952.             }
  953.         }
  954.     }
  955. }

  957. class ConnectionKeepAliveStrategyCustom implements ConnectionKeepAliveStrategy{

  959.     @Override
  960.     public long getKeepAliveDuration(HttpResponse response, HttpContext context) {
  961.         
  962.          // Honor 'keep-alive' header
  963.         HeaderElementIterator it = new BasicHeaderElementIterator(
  964.                 response.headerIterator(HTTP.CONN_KEEP_ALIVE));
  965.         while (it.hasNext()) {
  966.             HeaderElement he = it.nextElement();
  967.             String param = he.getName(); 
  968.             String value = he.getValue();
  969.             if (value != null && param.equalsIgnoreCase("timeout")) {
  970.                 try {
  971.                     //System.out.println("RETURN HEADER ["+ (Long.parseLong(value) * 1000)+"]");
  972.                     return Long.parseLong(value) * 1000;
  973.                 } catch(NumberFormatException ignore) {
  974.                 }
  975.             }
  976.         }
  977. //        HttpHost target = (HttpHost) context.getAttribute(
  978. //                ExecutionContext.HTTP_TARGET_HOST);
  979. //        if ("www.naughty-server.com".equalsIgnoreCase(target.getHostName())) {
  980. //            // Keep alive for 5 seconds only
  981. //            return 5 * 1000;
  982. //        } else {
  983. //            // otherwise keep alive for 30 seconds
  984. //            return 30 * 1000;
  985. //        }
  986.         // otherwise keep alive for 2 minutes
  987.         //System.out.println("RETURN 2 minuti");
  988.         return 2l * 60l * 1000l;
  989.         
  990.     }
  991.     
  992. }

  994. class CustomHttpEntity extends HttpEntityEnclosingRequestBase{

  996.     private HttpRequestMethod httpMethod;
  997.     public CustomHttpEntity(HttpRequestMethod httpMethod) {
  998.         super();
  999.         this.httpMethod = httpMethod;
  1000.     } 
  1001.     
  1002.     public CustomHttpEntity(HttpRequestMethod httpMethod, final URI uri) {
  1003.         super();
  1004.         setURI(uri);
  1005.         this.httpMethod = httpMethod;
  1006.     }

  1008.     public CustomHttpEntity(HttpRequestMethod httpMethod, final String uri) {
  1009.         super();
  1010.         setURI(URI.create(uri));
  1011.         this.httpMethod = httpMethod;
  1012.     }
  1013.     
  1014.     @Override
  1015.     public String getMethod() {
  1016.         return this.httpMethod.name();
  1017.     }
  1018.     
  1019. }
Created with JaCoCo 0.8.8.202204050719