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



  23. package org.openspcoop2.pdd.services.connector;

  25. import java.io.BufferedReader;
  26. import java.io.IOException;
  27. import java.io.StringReader;
  28. import java.util.ArrayList;
  29. import java.util.HashMap;
  30. import java.util.List;
  31. import java.util.Map;

  33. import javax.servlet.ServletException;
  34. import javax.servlet.http.HttpServlet;
  35. import javax.servlet.http.HttpServletRequest;
  36. import javax.servlet.http.HttpServletResponse;

  38. import org.apache.commons.lang.StringUtils;
  39. import org.openspcoop2.core.commons.CoreException;
  40. import org.openspcoop2.core.constants.Costanti;
  41. import org.openspcoop2.pdd.config.DynamicClusterManager;
  42. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  43. import org.openspcoop2.pdd.core.CostantiPdD;
  44. import org.openspcoop2.pdd.core.jmx.ConfigurazionePdD;
  45. import org.openspcoop2.pdd.core.jmx.GestoreConsegnaApplicativi;
  46. import org.openspcoop2.pdd.core.jmx.GestoreRichieste;
  47. import org.openspcoop2.pdd.core.jmx.JMXUtils;
  48. import org.openspcoop2.pdd.core.jmx.MonitoraggioRisorse;
  49. import org.openspcoop2.pdd.core.jmx.StatoServiziJMXResource;
  50. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  51. import org.openspcoop2.pdd.services.OpenSPCoop2Startup;
  52. import org.openspcoop2.pdd.services.connector.proxy.IProxyOperationService;
  53. import org.openspcoop2.pdd.services.connector.proxy.ProxyOperation;
  54. import org.openspcoop2.pdd.services.connector.proxy.ProxyOperationServiceFactory;
  55. import org.openspcoop2.protocol.sdk.state.URLProtocolContext;
  56. import org.openspcoop2.utils.LoggerWrapperFactory;
  57. import org.openspcoop2.utils.UtilsException;
  58. import org.openspcoop2.utils.datasource.JmxDataSource;
  59. import org.openspcoop2.utils.date.DateManager;
  60. import org.openspcoop2.utils.transport.TransportUtils;
  61. import org.openspcoop2.utils.transport.http.HttpConstants;
  62. import org.openspcoop2.utils.transport.http.HttpRequest;
  63. import org.openspcoop2.utils.transport.http.HttpRequestMethod;
  64. import org.openspcoop2.utils.transport.http.HttpResponse;
  65. import org.openspcoop2.utils.transport.http.HttpServletCredential;
  66. import org.openspcoop2.utils.transport.http.HttpUtilities;
  67. import org.slf4j.Logger;

  69. /**
  70.  * Proxy
  71.  *
  72.  * @author Poli Andrea (apoli@link.it)
  73.  * @author $Author$
  74.  * @version $Rev$, $Date$
  75.  */

  77. public class Proxy extends HttpServlet {

  79.      /**
  80.      * serialVersionUID
  81.      */
  82.     private static final long serialVersionUID = 1L;

  84.     private static final String SERVIZIO_NON_ABILITATO = "Servizio non abilitato";
  85.     private static final String SERVIZIO_NON_DISPONIBILE = "Servizio non disponibile";
  86.     
  87.     private static void logError(Logger log, String msg, Throwable e) {
  88.         log.error(msg, e);
  89.     }
  90.     private static void logError(Logger log, String msg) {
  91.         log.error(msg);
  92.     }
  93.     private static void logDebug(Logger log, String msg) {
  94.         log.debug(msg);
  95.     }
  96.     
  97.     private static void sendError(HttpServletResponse res, Logger log, String msg, int code) {
  98.         sendError(res, log, msg, code, msg, null);
  99.     }
  100.     @SuppressWarnings("unused")
  101.     private static void sendError(HttpServletResponse res, Logger log, String msg, int code, Throwable e) {
  102.         sendError(res, log, msg, code, msg, e);
  103.     }
  104.     private static void sendError(HttpServletResponse res, Logger log, String msg, int code, String logMsg) {
  105.         sendError(res, log, msg, code, logMsg, null);
  106.     }
  107.     private static void sendError(HttpServletResponse res, Logger log, String msg, int code, String logMsg, Throwable e) {
  108.         String prefix = "[Proxy] ";
  109.         if(e!=null) {
  110.             logError(log,prefix+logMsg, e);
  111.         }
  112.         else {
  113.             logError(log,prefix+logMsg);
  114.         }
  115.         res.setStatus(code);
  116.         res.setContentType(HttpConstants.CONTENT_TYPE_PLAIN);
  117.         try {
  118.             res.getOutputStream().write(msg.getBytes());
  119.         }catch(Exception t) {
  120.             logError(log,"[Proxy] SendError failed: "+t.getMessage(),t);
  121.         }
  122.     }

  124.     private static boolean saveContextOnlyOperation = true;
  125.     public static boolean isSaveContextOnlyOperation() {
  126.         return saveContextOnlyOperation;
  127.     }
  128.     public static void setSaveContextOnlyOperation(boolean saveContextOnlyOperation) {
  129.         Proxy.saveContextOnlyOperation = saveContextOnlyOperation;
  130.     }
  131.     
  132.     @Override public void doGet(HttpServletRequest req, HttpServletResponse res)
  133.     throws ServletException, IOException {
  134.         
  135.         Logger log = OpenSPCoop2Logger.getLoggerOpenSPCoopProxy();
  136.         if(log==null)
  137.             log = LoggerWrapperFactory.getLogger(Proxy.class);
  138.         
  139.         if( !OpenSPCoop2Startup.initialize){
  140.             CheckStatoPdD.serializeNotInitializedResponse(res, log);
  141.             return;
  142.         }
  143.         
  144.         OpenSPCoop2Properties properties = OpenSPCoop2Properties.getInstance();
  145.         
  146.         boolean proxyEnabled = false;
  147.         if(properties!=null && properties.isProxyReadJMXResourcesEnabled() ){
  148.             proxyEnabled = true;
  149.         }
  150.         if(!proxyEnabled){
  151.             String msg = SERVIZIO_NON_ABILITATO;
  152.             sendError(res, log, msg, 500); 
  153.             return;
  154.         }
  155.                 
  156.         // verifico l'esistenza di nodi
  157.         List<String> list = null;
  158.         try {
  159.             list = DynamicClusterManager.getInstance().getHostnames(log);
  160.         }catch(Exception e) {
  161.             String msg = SERVIZIO_NON_DISPONIBILE;
  162.             String logMsg = msg+": "+e.getMessage();
  163.             sendError(res, log, msg, 500, logMsg, e); 
  164.             return;
  165.         }
  166.         
  167.         boolean asyncMode = properties.isProxyReadJMXResourcesAsyncProcessByTimer();
  168.         IProxyOperationService proxyOperationService = null;
  169.         if(asyncMode) {
  170.             String className = properties.getProxyReadJMXResourcesAsyncProcessByTimerServiceImplClass();
  171.             try {
  172.                 proxyOperationService = ProxyOperationServiceFactory.newInstance(className, log);
  173.             }catch(Exception e) {
  174.                 String msg = SERVIZIO_NON_DISPONIBILE;
  175.                 String logMsg = msg+": "+e.getMessage();
  176.                 sendError(res, log, msg, 500, logMsg, e); 
  177.                 return;
  178.             }
  179.         }
  180.                 
  181.         // === Costruisco nuova url ===
  182.         
  183.         // schema
  184.         String protocolSchema = properties.getProxyReadJMXResourcesSchema();
  185.         if(asyncMode) {
  186.             String tmp = properties.getProxyReadJMXResourcesAsyncProcessByTimerSchema();
  187.             if(tmp!=null && StringUtils.isNotEmpty(tmp)) {
  188.                 protocolSchema = tmp;
  189.             }
  190.         }
  191.         if(protocolSchema==null || StringUtils.isEmpty(protocolSchema)) {
  192.             protocolSchema = req.getScheme();
  193.         }
  194.         String protocol = (protocolSchema!=null && protocolSchema.trim().toLowerCase().startsWith("https")) ? "https://" : "http://";
  195.         
  196.         // hostname (solo in caso async-mode)
  197.         String hostnameAsync = null;
  198.         if(asyncMode) {
  199.             hostnameAsync = properties.getProxyReadJMXResourcesAsyncProcessByTimerHostname();
  200.         }
  201.         
  202.         // port
  203.         int port = req.getLocalPort();
  204.         if(asyncMode && properties.getProxyReadJMXResourcesAsyncProcessByTimerPort()!=null && properties.getProxyReadJMXResourcesAsyncProcessByTimerPort().intValue()>0) {
  205.             port = properties.getProxyReadJMXResourcesAsyncProcessByTimerPort().intValue();
  206.         }
  207.         else if(properties.getProxyReadJMXResourcesPort()!=null && properties.getProxyReadJMXResourcesPort().intValue()>0) {
  208.             port = properties.getProxyReadJMXResourcesPort().intValue();
  209.         }
  210.         
  211.         // context
  212.         String context = req.getContextPath();
  213.         if(!context.endsWith("/")) {
  214.             context = context + "/";
  215.         }
  216.         context = context + URLProtocolContext.Check_FUNCTION;
  217.         
  218.         // paramters
  219.         Map<String, List<String>> parameters = buildParameters(req);
  220.         
  221.         // Https
  222.         boolean https = properties.isProxyReadJMXResourcesHttpsEnabled();
  223.         boolean verificaHostname = false;
  224.         boolean autenticazioneServer = false;
  225.         String autenticazioneServerPath = null;
  226.         String autenticazioneServerType = null;
  227.         String autenticazioneServerPassword = null;
  228.         if(https) {
  229.             verificaHostname = properties.isProxyReadJMXResourcesHttpsEnabledVerificaHostName();
  230.             autenticazioneServer = properties.isProxyReadJMXResourcesHttpsEnabledAutenticazioneServer();
  231.             if(autenticazioneServer) {
  232.                 autenticazioneServerPath = properties.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePath();
  233.                 autenticazioneServerType = properties.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststoreType();
  234.                 autenticazioneServerPassword = properties.getProxyReadJMXResourcesHttpsEnabledAutenticazioneServerTruststorePassword();
  235.             }
  236.         }
  237.         
  238.         // Timeout
  239.         int readTimeout = properties.getProxyReadJMXResourcesReadTimeout();
  240.         int connectTimeout = properties.getProxyReadJMXResourcesConnectionTimeout();
  241.         
  242.         // Vengono utilizzate le credenziali del servizio check che dovranno essere uguali su tutti i nodi
  243.         String usernameCheck = properties.getCheckReadJMXResourcesUsername();
  244.         String passwordCheck = properties.getCheckReadJMXResourcesPassword();
  245.         
  246.         
  247.         // === Avvio gestione ===
  248.         
  249.         String resourceName = req.getParameter(CostantiPdD.CHECK_STATO_PDD_RESOURCE_NAME);
  250.         if(resourceName!=null && !"".equals(resourceName)){
  251.             
  252.             // prima di procedere verifico una eventuale autenticazione
  253.             String username = properties.getProxyReadJMXResourcesUsername();
  254.             String password = properties.getProxyReadJMXResourcesPassword();
  255.             if(username!=null && password!=null){
  256.                 HttpServletCredential identity = new HttpServletCredential(req, log);
  257.                 if(!username.equals(identity.getUsername())){
  258.                     String msg = "Servizio non autorizzato";
  259.                     String logMsg = msg+". Richiesta effettuata da username ["+identity.getUsername()+"] sconosciuto";
  260.                     sendError(res, log, msg, 500, logMsg);  
  261.                     return;
  262.                 }
  263.                 if(!password.equals(identity.getPassword())){
  264.                     String msg = "Servizio non autorizzato";
  265.                     String logMsg = msg+". Richiesta effettuata da username ["+identity.getUsername()+"] (password errata)";
  266.                     sendError(res, log, msg, 500, logMsg);  
  267.                     return;
  268.                 }
  269.             }
  270.             
  271.             /*
  272.              *  metodi void: in questo caso rientrano le reset cache. 
  273.              *                Il servizio proxy invocherà ogni nodo. 
  274.              *                Se anche solo uno dei nodi restituisce errore, viene ritornato quell’errore (si tratta di un caso anormale).
  275.              *                
  276.              *  metodi che devono restituire una stringa: in questo caso il servizio invocherà solamente un nodo a caso 
  277.              *                poichè ogni nodo sono indistinguibili uno dall’altro. 
  278.              *                In questa casistica dovranno essere gestiti con eccezione alcuni metodi specifici (es. Numero di thread attivi o numero di connessioni attivi) 
  279.              *                per i quali si dovranno invocare tutti i nodi e aggregare i risultati.
  280.              * */
  281.             
  282.             String attributeName = req.getParameter(CostantiPdD.CHECK_STATO_PDD_ATTRIBUTE_NAME);
  283.             String attributeValue = req.getParameter(CostantiPdD.CHECK_STATO_PDD_ATTRIBUTE_VALUE);
  284.             String attributeBooleanValue = req.getParameter(CostantiPdD.CHECK_STATO_PDD_ATTRIBUTE_BOOLEAN_VALUE);
  285.             String methodName = req.getParameter(CostantiPdD.CHECK_STATO_PDD_METHOD_NAME);
  286.             String parameterValues = formatParameters(req);
  287.             logDebug(log,"==============");
  288.             if(attributeName!=null){
  289.                 logDebug(log,"resourceName["+resourceName+"] attributeName["+attributeName+"] attributeValue["+attributeValue+"] attributeBooleanValue["+attributeBooleanValue+"] ...");
  290.             }
  291.             else {
  292.                 logDebug(log,"resourceName["+resourceName+"] methodName["+methodName+"]"+parameterValues+" ...");
  293.             }
  294.             boolean invokeAllNodes = false;
  295.             boolean aggregate = false;
  296.             
  297.             String resourcePrefix = "[resource: "+resourceName+"] ";
  298.             String tipoOperazioneAsync = null;
  299.             int asyncCheckInterval = properties.getProxyReadJMXResourcesAsyncProcessByTimerCheckInterval();
  300.             if(asyncMode) {
  301.                 if(attributeName!=null && (attributeValue!=null || attributeBooleanValue!=null)) {
  302.                     tipoOperazioneAsync = resourcePrefix+"setAttribute '"+attributeName+"'";        
  303.                 }
  304.                 else {
  305.                     tipoOperazioneAsync = resourcePrefix+methodName;
  306.                 }
  307.             }
  308.             
  309.             if(attributeName!=null && (attributeValue!=null || attributeBooleanValue!=null)) {
  310.                 invokeAllNodes = true; // setAttribute
  311.             }
  312.             else if(methodName!=null){
  313.                 if(JMXUtils.CACHE_METHOD_NAME_RESET.equals(methodName) || 
  314.                         JMXUtils.CACHE_METHOD_NAME_REMOVE_OBJECT.equals(methodName)) {
  315.                     invokeAllNodes = true;
  316.                 }
  317.                 else if(CostantiPdD.JMX_GESTORE_RICHIESTE.equals(resourceName)
  318.                         &&
  319.                         (GestoreRichieste.CACHE_METHOD_NAME_REMOVE_DATI_CONTROLLO_TRAFFICO_GLOBALE.equals(methodName)
  320.                                 ||
  321.                                 GestoreRichieste.CACHE_METHOD_NAME_REMOVE_DATI_CONTROLLO_TRAFFICO_API.equals(methodName))
  322.                     ) {
  323.                     invokeAllNodes = true;
  324.                 }
  325.                 else if(CostantiPdD.JMX_CONFIGURAZIONE_PDD.equals(resourceName)
  326.                         &&
  327.                         (
  328.                                 methodName.startsWith(ConfigurazionePdD.RIPULISCI_RIFERIMENTI_CACHE_PREFIX)
  329.                                 ||
  330.                                 ConfigurazionePdD.ABILITA_PORTA_DELEGATA.equals(methodName)
  331.                                 ||
  332.                                 ConfigurazionePdD.DISABILITA_PORTA_DELEGATA.equals(methodName)
  333.                                 ||
  334.                                 ConfigurazionePdD.ABILITA_PORTA_APPLICATIVA.equals(methodName)
  335.                                 ||
  336.                                 ConfigurazionePdD.DISABILITA_PORTA_APPLICATIVA.equals(methodName)
  337.                                 ||
  338.                                 ConfigurazionePdD.ABILITA_CONNETTORE_MULTIPLO.equals(methodName)
  339.                                 ||
  340.                                 ConfigurazionePdD.DISABILITA_CONNETTORE_MULTIPLO.equals(methodName)
  341.                                 ||
  342.                                 ConfigurazionePdD.ABILITA_SCHEDULING_CONNETTORE_MULTIPLO.equals(methodName)
  343.                                 ||
  344.                                 ConfigurazionePdD.DISABILITA_SCHEDULING_CONNETTORE_MULTIPLO.equals(methodName)
  345.                                 ||
  346.                                 ConfigurazionePdD.ABILITA_SCHEDULING_CONNETTORE_MULTIPLO_RUNTIME.equals(methodName)
  347.                                 ||
  348.                                 ConfigurazionePdD.DISABILITA_SCHEDULING_CONNETTORE_MULTIPLO_RUNTIME.equals(methodName)
  349.                         )
  350.                         ) {
  351.                     invokeAllNodes = true;
  352.                 }
  353.                 else if(CostantiPdD.JMX_STATO_SERVIZI_PDD.equals(resourceName)
  354.                         &&
  355.                         (
  356.                                 StatoServiziJMXResource.ABILITA_COMPONENTE_PD.equals(methodName)
  357.                                 ||
  358.                                 StatoServiziJMXResource.DISABILITA_COMPONENTE_PD.equals(methodName)
  359.                                 ||
  360.                                 StatoServiziJMXResource.ABILITA_COMPONENTE_PA.equals(methodName)
  361.                                 ||
  362.                                 StatoServiziJMXResource.DISABILITA_COMPONENTE_PA.equals(methodName)
  363.                                 ||
  364.                                 StatoServiziJMXResource.ABILITA_COMPONENTE_IM.equals(methodName)
  365.                                 ||
  366.                                 StatoServiziJMXResource.DISABILITA_COMPONENTE_IM.equals(methodName)
  367.                         )
  368.                         ) {
  369.                     invokeAllNodes = true;
  370.                 }
  371.                 else if(CostantiPdD.JMX_LOAD_BALANCER.equals(resourceName)
  372.                         &&
  373.                         (
  374.                                 GestoreConsegnaApplicativi.UPDATE_CONNETTORI_PRIORITARI.equals(methodName)
  375.                                 ||
  376.                                 GestoreConsegnaApplicativi.RESET_CONNETTORI_PRIORITARI.equals(methodName)
  377.                         )
  378.                         ) {
  379.                     invokeAllNodes = true;
  380.                 }
  381.                 else if(
  382.                         (
  383.                                 CostantiPdD.JMX_MONITORAGGIO_RISORSE.equals(resourceName) 
  384.                                 &&
  385.                                 (
  386.                                     MonitoraggioRisorse.CONNESSIONI_ALLOCATE_DB_MANAGER.equals(methodName)
  387.                                     ||
  388.                                     MonitoraggioRisorse.CONNESSIONI_ALLOCATE_QUEUE_MANAGER.equals(methodName)
  389.                                     ||
  390.                                     MonitoraggioRisorse.TRANSAZIONI_ATTIVE_ID.equals(methodName)
  391.                                     ||
  392.                                     MonitoraggioRisorse.TRANSAZIONI_ATTIVE_ID_PROTOCOLLO.equals(methodName)
  393.                                     ||
  394.                                     MonitoraggioRisorse.CONNESSIONI_ALLOCATE_CONNETTORI_PD.equals(methodName)
  395.                                     ||
  396.                                     MonitoraggioRisorse.CONNESSIONI_ALLOCATE_CONNETTORI_PA.equals(methodName)
  397.                                 )   
  398.                         )
  399.                         
  400.                         ||
  401.                         
  402.                         (
  403.                                 Costanti.JMX_NAME_DATASOURCE_PDD.equals(resourceName)
  404.                                 &&
  405.                                 JmxDataSource.CONNESSIONI_ALLOCATE.equals(methodName)
  406.                         )
  407.                         
  408.                         ||
  409.                         
  410.                         (
  411.                                 CostantiPdD.JMX_LOAD_BALANCER.equals(resourceName)
  412.                                 &&
  413.                                 GestoreConsegnaApplicativi.THREAD_POOL_STATUS.equals(methodName)
  414.                         )
  415.                     ){
  416.                     invokeAllNodes = true;
  417.                     aggregate = true;
  418.                     if(asyncMode) {
  419.                         String msg = SERVIZIO_NON_DISPONIBILE;
  420.                         String logMsg = msg+". L'operazione richiesta ("+resourcePrefix+methodName+") richiede un'aggregazione non attuabile in modalità asincrona";
  421.                         sendError(res, log, msg, 500, logMsg);  
  422.                         return;
  423.                     }
  424.                 }
  425.                         
  426.             }
  427.             
  428.             if(invokeAllNodes) {
  429.                 
  430.                 // Se anche solo uno dei nodi restituisce errore, viene ritornato quell’errore (si tratta di un caso anormale).
  431.                 /**String urlHttpResponseFailed = null;*/
  432.                 HttpResponse httpResponseFailed = null;
  433.                 /**String urlHttpResponseOk = null;*/
  434.                 HttpResponse httpResponseOk = null;
  435.                 String urlT = null;
  436.                 Throwable t = null;
  437.                 ResultAggregate resultAggregate = null;
  438.                 
  439.                 logDebug(log,"Invoke all node ...");
  440.                                 
  441.                 List<String> lUsed = list;
  442.                 if(asyncMode) {
  443.                     // effettuo solo una registrazione
  444.                     lUsed = new ArrayList<>();
  445.                     lUsed.add("localhost"); // verra poi sostituito con hostnameAsync
  446.                 }
  447.                 
  448.                 for (String hostname : lUsed) {
  449.                     String url = null;
  450.                     try {
  451.                         /**System.out.println("DEBUG");
  452.                         if("Erogatore".equals(hostname)) {
  453.                             port = 8180;
  454.                         }
  455.                         else {
  456.                             port = 8080;
  457.                         }
  458.                         System.out.println("DEBUG");*/
  459.                         
  460.                         String hostnameUsed = hostname;
  461.                         if(asyncMode && hostnameAsync!=null && StringUtils.isNotEmpty(hostnameAsync)) {
  462.                             hostnameUsed = hostnameAsync;
  463.                         }
  464.                         
  465.                         int portUsed = port;
  466.                         Integer portHostname = properties.getProxyReadJMXResourcesPort(hostname);
  467.                         if(portHostname!=null && portHostname.intValue()>0) {
  468.                             portUsed = portHostname.intValue();
  469.                         }
  470.                         
  471.                         boolean addContext = !asyncMode || !saveContextOnlyOperation;
  472.                         url = buildUrl(log, addContext, protocol, hostnameUsed, portUsed, context, parameters);
  473.                         
  474.                         if(aggregate && asyncMode) {
  475.                             // c'e' un controllo prima e quindi questa eccezione non dovrebbe avvenire
  476.                             throw new CoreException("L'operazione richiesta ("+url+") richiede un'aggregazione non attuabile in modalità asincrona");
  477.                         }
  478.                         
  479.                         HttpResponse httpResponse = null;
  480.                         if(asyncMode) {
  481.                             /**System.out.println("SAVE ALL METHOD BY URL '"+url+"'");*/
  482.                             httpResponse = saveOperation(proxyOperationService, url, tipoOperazioneAsync, log, asyncCheckInterval);
  483.                         }
  484.                         else {
  485.                             /**System.out.println("INVOKE ALL METHOD BY URL '"+url+"'");*/
  486.                             httpResponse = invokeHttp(url, 
  487.                                     readTimeout, connectTimeout, 
  488.                                     usernameCheck, passwordCheck,
  489.                                     https, verificaHostname, autenticazioneServer,
  490.                                     autenticazioneServerPath, autenticazioneServerType,  autenticazioneServerPassword);
  491.                         }
  492.                         
  493.                         String sResponse = null;
  494.                         if(httpResponse.getContent()!=null) {
  495.                             sResponse = new String(httpResponse.getContent());
  496.                         }
  497.                         boolean error = sResponse!=null && sResponse.startsWith(JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA);
  498.                         
  499.                         if(httpResponse.getResultHTTPOperation()==200 && !error) {
  500.                             if(httpResponseOk==null) {
  501.                                 httpResponseOk = httpResponse;
  502.                                 /**urlHttpResponseOk = url;*/
  503.                             }
  504.                             if(aggregate) {
  505.                                 if(resultAggregate==null) {
  506.                                     resultAggregate = new ResultAggregate(resourceName, methodName);
  507.                                 }
  508.                                 resultAggregate.addResponse(sResponse, hostname);
  509.                             }
  510.                         }
  511.                         else {
  512.                             if(httpResponseFailed==null) {
  513.                                 httpResponseFailed = httpResponse;
  514.                                 /**urlHttpResponseFailed = url;*/
  515.                             }
  516.                         }
  517.                         
  518.                         logDebug(log,"Invoked '"+hostname+"' ("+httpResponse.getResultHTTPOperation()+")");
  519.                         
  520.                     }catch(Exception e) {
  521.                         String msg = "("+hostname+") Servizio non disponibile";
  522.                         t = new Exception(msg, e);
  523.                         urlT = url;
  524.                     }
  525.                 }
  526.                 
  527.                 if(t!=null) {
  528.                     String msg = t.getMessage();
  529.                     String logMsg = "error occurs: "+t.getMessage();
  530.                     sendError(res, log, msg, 500, logMsg, t);   
  531.                 }
  532.                 else if(httpResponseFailed!=null) {
  533.                     logDebug(log,"Invoke all node complete 'ERROR'");
  534.                     writeResponse(httpResponseFailed, res, log);
  535.                 }
  536.                 else if(resultAggregate!=null) {
  537.                     logDebug(log,"Invoke all node complete 'Aggregate OK'");
  538.                     writeResponse(resultAggregate.getHttpResponse(), res, log);
  539.                 }
  540.                 else if(httpResponseOk!=null) {
  541.                     logDebug(log,"Invoke all node complete 'OK'");
  542.                     writeResponse(httpResponseOk, res, log);
  543.                 }
  544.                 else {
  545.                     String msg = SERVIZIO_NON_DISPONIBILE;
  546.                     String logMsg = "'CasoNonPrevisto' (url: "+urlT+") "+msg;
  547.                     sendError(res, log, msg, 500, logMsg);  
  548.                 }

  550.             }
  551.             else {
  552.                 
  553.                 logDebug(log,"Invoke single node '"+list.get(0)+"' ...");
  554.                 
  555.                 // Viene invocato un nodo a caso (il primo essendo quello piu' vecchio)
  556.                 String url = null;
  557.                 try {
  558.                     
  559.                     String hostname = list.get(0);
  560.                     String hostnameUsed = hostname;
  561.                     if(asyncMode && hostnameAsync!=null && StringUtils.isNotEmpty(hostnameAsync)) {
  562.                         hostnameUsed = hostnameAsync;
  563.                     }
  564.                     
  565.                     int portUsed = port;
  566.                     Integer portHostname = properties.getProxyReadJMXResourcesPort(hostname);
  567.                     if(portHostname!=null && portHostname.intValue()>0) {
  568.                         portUsed = portHostname.intValue();
  569.                     }
  570.                     
  571.                     url = buildUrl(log, true, protocol, hostnameUsed, portUsed, context, parameters);
  572.                     /**System.out.println("INVOKE SINGLE METHOD BY URL '"+url+"'");*/
  573.                     HttpResponse httpResponse = invokeHttp(url, 
  574.                             readTimeout, connectTimeout, 
  575.                             usernameCheck, passwordCheck,
  576.                             https, verificaHostname, autenticazioneServer,
  577.                             autenticazioneServerPath, autenticazioneServerType,  autenticazioneServerPassword);
  578.                     writeResponse(httpResponse, res, log);
  579.                     
  580.                 }catch(Exception e) {
  581.                     String msg = SERVIZIO_NON_DISPONIBILE;
  582.                     String logMsg = msg+" (url: "+url+"): "+e.getMessage();
  583.                     sendError(res, log, msg, 500, logMsg, e);   
  584.                 }
  585.             }
  586.             
  587.         }
  588.         else {
  589.             
  590.             logDebug(log,"Invoke single node CHECK '"+list.get(0)+"' ...");
  591.             
  592.             // Servizio check del gateway
  593.             // Viene invocato un nodo a caso (il primo essendo quello piu' vecchio)
  594.             String url = null;
  595.             try {
  596.                 
  597.                 String hostname = list.get(0);
  598.                 String hostnameUsed = hostname;
  599.                 if(asyncMode && hostnameAsync!=null && StringUtils.isNotEmpty(hostnameAsync)) {
  600.                     hostnameUsed = hostnameAsync;
  601.                 }
  602.                 
  603.                 int portUsed = port;
  604.                 Integer portHostname = properties.getProxyReadJMXResourcesPort(hostname);
  605.                 if(portHostname!=null && portHostname.intValue()>0) {
  606.                     portUsed = portHostname.intValue();
  607.                 }
  608.                 
  609.                 url = buildUrl(log, true, protocol, hostnameUsed, portUsed, context, parameters);
  610.                 /**System.out.println("INVOKE SINGLE ATTRIBUTE BY URL '"+url+"'");*/
  611.                 HttpResponse httpResponse = invokeHttp(url, 
  612.                                 readTimeout, connectTimeout, 
  613.                                 usernameCheck, passwordCheck,
  614.                                 https, verificaHostname, autenticazioneServer,
  615.                                 autenticazioneServerPath, autenticazioneServerType,  autenticazioneServerPassword);
  616.                 writeResponse(httpResponse, res, log);
  617.             }catch(Exception e) {
  618.                 String msg = SERVIZIO_NON_DISPONIBILE;
  619.                 String logMsg = msg+" (url: "+url+"): "+e.getMessage();
  620.                 sendError(res, log, msg, 500, logMsg, e);   
  621.             }
  622.         }
  623.         

  625.     }
  626.     
  627.     public static HttpResponse invokeHttp(String url, 
  628.             int readTimeout, int connectTimeout, 
  629.             String usernameCheck, String passwordCheck,
  630.             boolean https, boolean verificaHostname, boolean autenticazioneServer,
  631.             String autenticazioneServerPath, String autenticazioneServerType, String autenticazioneServerPassword) throws UtilsException {
  632.         HttpResponse response = null;
  633.         if(https) {
  634.             HttpRequest httpRequest = new HttpRequest();
  635.             httpRequest.setUrl(url);
  636.             httpRequest.setConnectTimeout(connectTimeout);
  637.             httpRequest.setReadTimeout(readTimeout);
  638.             httpRequest.setUsername(usernameCheck);
  639.             httpRequest.setPassword(passwordCheck);
  640.             httpRequest.setMethod(HttpRequestMethod.GET);
  641.             httpRequest.setHostnameVerifier(verificaHostname);
  642.             if(autenticazioneServer) {
  643.                 httpRequest.setTrustStorePath(autenticazioneServerPath);
  644.                 httpRequest.setTrustStoreType(autenticazioneServerType);
  645.                 httpRequest.setTrustStorePassword(autenticazioneServerPassword);
  646.             }
  647.             else {
  648.                 httpRequest.setTrustAllCerts(true);
  649.             }
  650.             response = HttpUtilities.httpInvoke(httpRequest);
  651.         }
  652.         else {
  653.             response = HttpUtilities.getHTTPResponse(url,
  654.                     readTimeout, connectTimeout,
  655.                     usernameCheck, passwordCheck);
  656.         }
  657.         return response;
  658.     }
  659.     private HttpResponse saveOperation(IProxyOperationService proxyOperationService, String url, String description, Logger log, int asyncCheckInterval) {
  660.         HttpResponse response = new HttpResponse();
  661.         try {
  662.             
  663.             ProxyOperation proxyOperation = new ProxyOperation();
  664.             proxyOperation.setCommand(url);
  665.             proxyOperation.setDescription(description);
  666.             proxyOperation.setRegistrationTime(DateManager.getDate());
  667.             proxyOperationService.save(proxyOperation);
  668.             
  669.             response.setResultHTTPOperation(200);
  670.             response.setContentType(HttpConstants.CONTENT_TYPE_PLAIN);
  671.             response.setContent((JMXUtils.MSG_OPERAZIONE_EFFETTUATA_SUCCESSO_PREFIX+JMXUtils.MSG_OPERAZIONE_REGISTRATA_SUCCESSO.replace(JMXUtils.MSG_OPERAZIONE_REGISTRATA_SUCCESSO_TEMPLATE_SECONDI, asyncCheckInterval+"")).getBytes());
  672.         }catch(Exception t) {
  673.             response.setResultHTTPOperation(500);
  674.             response.setContentType(HttpConstants.CONTENT_TYPE_PLAIN);
  675.             logError(log,"[Proxy] saveOperation failed: "+t.getMessage(),t);
  676.             response.setContent((JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+t.getMessage()).getBytes());
  677.         }
  678.         return response;
  679.     }

  681.     private void writeResponse(HttpResponse httpResponse, HttpServletResponse res, Logger log) {
  682.         try {
  683.             res.setStatus(httpResponse.getResultHTTPOperation());
  684.             if(httpResponse.getContentType()!=null) {
  685.                 res.setContentType(httpResponse.getContentType());
  686.             }
  687.             if(httpResponse.getContent()!=null) {
  688.                 res.getOutputStream().write(httpResponse.getContent());
  689.             }
  690.         }catch(Exception t) {
  691.             logError(log,"[Proxy] WriteResponse failed: "+t.getMessage(),t);
  692.         }
  693.     }
  694.     
  695.     private String buildUrl(Logger log, boolean addContext, String protocol, String hostname, int port, String context, Map<String, List<String>> parameters ) {
  696.         StringBuilder sb = new StringBuilder();
  697.         if(addContext) {
  698.             sb.append(protocol);
  699.             sb.append(hostname);
  700.             sb.append(":");
  701.             sb.append(port);
  702.         }
  703.         sb.append(context);
  704.         return TransportUtils.buildUrlWithParameters(parameters, sb.toString(), log);
  705.     }
  706.     
  707.     private Map<String, List<String>> buildParameters(HttpServletRequest req) {
  708.         Map<String, List<String>> parameters = new HashMap<>();        
  709.         java.util.Enumeration<?> en = req.getParameterNames();
  710.         while(en.hasMoreElements()){
  711.             String nomeProperty = (String)en.nextElement();
  712.             String [] s = req.getParameterValues(nomeProperty);
  713.             List<String> values = new ArrayList<>();
  714.             if(s!=null && s.length>0) {
  715.                 for (int i = 0; i < s.length; i++) {
  716.                     String value = s[i];
  717.                     values.add(value);
  718.                 }
  719.             }
  720.             else {
  721.                 values.add(req.getParameter(nomeProperty));
  722.             }
  723.             parameters.put(nomeProperty,values);
  724.         }
  725.         return parameters;
  726.     }
  727.     
  728.     private static String formatParameters(HttpServletRequest req) {
  729.         StringBuilder sb = new StringBuilder("");
  730.         
  731.         String paramValue = req.getParameter(CostantiPdD.CHECK_STATO_PDD_PARAM_VALUE);
  732.         if(paramValue!=null) {
  733.             sb.append(" ").append("paramValue[").append(paramValue).append("]");
  734.         }
  735.         paramValue = req.getParameter(CostantiPdD.CHECK_STATO_PDD_PARAM_INT_VALUE);
  736.         if(paramValue!=null) {
  737.             sb.append(" ").append("paramIntValue[").append(paramValue).append("]");
  738.         }
  739.         paramValue = req.getParameter(CostantiPdD.CHECK_STATO_PDD_PARAM_LONG_VALUE);
  740.         if(paramValue!=null) {
  741.             sb.append(" ").append("paramLongValue[").append(paramValue).append("]");
  742.         }
  743.         paramValue = req.getParameter(CostantiPdD.CHECK_STATO_PDD_PARAM_BOOLEAN_VALUE);
  744.         if(paramValue!=null) {
  745.             sb.append(" ").append("paramBooleanValue[").append(paramValue).append("]");
  746.         }
  747.         
  748.         paramValue = req.getParameter(CostantiPdD.CHECK_STATO_PDD_PARAM_VALUE_2);
  749.         if(paramValue!=null) {
  750.             sb.append(" ").append("paramValue2[").append(paramValue).append("]");
  751.         }
  752.         paramValue = req.getParameter(CostantiPdD.CHECK_STATO_PDD_PARAM_INT_VALUE_2);
  753.         if(paramValue!=null) {
  754.             sb.append(" ").append("paramIntValue2[").append(paramValue).append("]");
  755.         }
  756.         paramValue = req.getParameter(CostantiPdD.CHECK_STATO_PDD_PARAM_LONG_VALUE_2);
  757.         if(paramValue!=null) {
  758.             sb.append(" ").append("paramLongValue2[").append(paramValue).append("]");
  759.         }
  760.         paramValue = req.getParameter(CostantiPdD.CHECK_STATO_PDD_PARAM_BOOLEAN_VALUE_2);
  761.         if(paramValue!=null) {
  762.             sb.append(" ").append("paramBooleanValue2[").append(paramValue).append("]");
  763.         }
  764.         
  765.         paramValue = req.getParameter(CostantiPdD.CHECK_STATO_PDD_PARAM_VALUE_3);
  766.         if(paramValue!=null) {
  767.             sb.append(" ").append("paramValue3[").append(paramValue).append("]");
  768.         }
  769.         paramValue = req.getParameter(CostantiPdD.CHECK_STATO_PDD_PARAM_INT_VALUE_3);
  770.         if(paramValue!=null) {
  771.             sb.append(" ").append("paramIntValue3[").append(paramValue).append("]");
  772.         }
  773.         paramValue = req.getParameter(CostantiPdD.CHECK_STATO_PDD_PARAM_LONG_VALUE_3);
  774.         if(paramValue!=null) {
  775.             sb.append(" ").append("paramLongValue3[").append(paramValue).append("]");
  776.         }
  777.         paramValue = req.getParameter(CostantiPdD.CHECK_STATO_PDD_PARAM_BOOLEAN_VALUE_3);
  778.         if(paramValue!=null) {
  779.             sb.append(" ").append("paramBooleanValue3[").append(paramValue).append("]");
  780.         }
  781.         
  782.         return sb.toString();
  783.     }
  784. }

  786. class ResultAggregate {
  787.     
  788.     private String resourceName;
  789.     private String methodName;
  790.     private List<String> list1 = new ArrayList<>();
  791.     private List<String> list2 = new ArrayList<>();
  792.     private List<String> list3 = new ArrayList<>();
  793.     private List<String> list4 = new ArrayList<>();
  794.     private List<String> list5 = new ArrayList<>();
  795.     private List<String> list6 = new ArrayList<>();
  796.     private List<String> list7 = new ArrayList<>();
  797.     private List<String> list8 = new ArrayList<>();
  798.     
  799.     ResultAggregate(String resourceName, String methodName){
  800.         this.resourceName = resourceName;
  801.         this.methodName = methodName;
  802.     }
  803.     
  804.     public void addResponse(String sResponse, String hostname) throws IOException {
  805.         if(sResponse==null) {
  806.             return;
  807.         }
  808.         try(StringReader sReader = new StringReader(sResponse);
  809.             BufferedReader bReader = new BufferedReader(sReader)) {
  810.             String line = bReader.readLine();
  811.             List<String> listUse = this.list1;
  812.             while (line != null) {
  813.                 if(MonitoraggioRisorse.MSG_NESSUNA_CONNESSIONE_ALLOCATA.equals(line) ||
  814.                         MonitoraggioRisorse.MSG_NESSUNA_TRANSAZIONE_ATTIVA.equals(line) ||
  815.                         JmxDataSource.MSG_NESSUNA_CONNESSIONE_ALLOCATA.equals(line)) {
  816.                     break;
  817.                 }
  818.                 try {
  819.                     if(line.contains(MonitoraggioRisorse.MSG_CONNESSIONI_ALLOCATE) ||
  820.                             line.contains(MonitoraggioRisorse.MSG_CONNESSIONI_HTTP_ALLOCATE) ||
  821.                             line.contains(MonitoraggioRisorse.MSG_TRANSAZIONI_ATTIVE) ||
  822.                             line.contains(MonitoraggioRisorse.MSG_TRANSAZIONI_ATTIVE_ID_PROTOCOLLO) ||
  823.                             line.contains(JmxDataSource.MSG_CONNESSIONI_ALLOCATE)) {
  824.                         continue;
  825.                     }
  826.                     if(line.contains(MonitoraggioRisorse.MSG_CONNESSIONI_ALLOCATE_TRANSAZIONI)) {
  827.                         listUse = this.list2;
  828.                         continue;
  829.                     }
  830.                     if(line.contains(MonitoraggioRisorse.MSG_CONNESSIONI_ALLOCATE_STATISTICHE)) {
  831.                         listUse = this.list3;
  832.                         continue;
  833.                     }
  834.                     if(line.contains(MonitoraggioRisorse.MSG_CONNESSIONI_ALLOCATE_CONSEGNE_PRESE_IN_CARICO_SMISTATORE)) {
  835.                         listUse = this.list4;
  836.                         continue;
  837.                     }
  838.                     if(line.contains(MonitoraggioRisorse.MSG_CONNESSIONI_ALLOCATE_CONSEGNE_PRESE_IN_CARICO_RUNTIME)) {
  839.                         listUse = this.list5;
  840.                         continue;
  841.                     }
  842.                     if(line.contains(MonitoraggioRisorse.MSG_CONNESSIONI_ALLOCATE_CONSEGNE_PRESE_IN_CARICO_TRANSAZIONI)) {
  843.                         listUse = this.list6;
  844.                         continue;
  845.                     }
  846.                     if(line.contains(MonitoraggioRisorse.MSG_CONNESSIONI_ALLOCATE_CONSEGNE_MESSAGE_BOX_RUNTIME)) {
  847.                         listUse = this.list7;
  848.                         continue;
  849.                     }
  850.                     if(line.contains(MonitoraggioRisorse.MSG_CONNESSIONI_ALLOCATE_CONSEGNE_MESSAGE_BOX_TRANSAZIONI)) {
  851.                         listUse = this.list8;
  852.                         continue;
  853.                     }
  854.                     
  855.                     listUse.add(line+" ["+hostname+"]");
  856.                 }finally {
  857.                     // read next line
  858.                     line = bReader.readLine();
  859.                 }
  860.             }
  861.         }
  862.     }
  863.     
  864.     public HttpResponse getHttpResponse() {
  865.         HttpResponse httpResponse = new HttpResponse();
  866.         httpResponse.setResultHTTPOperation(200);
  867.         
  868.         String content = null;
  869.         if(CostantiPdD.JMX_MONITORAGGIO_RISORSE.equals(this.resourceName)) {
  870.             if(MonitoraggioRisorse.CONNESSIONI_ALLOCATE_DB_MANAGER.equals(this.methodName) ||
  871.                     MonitoraggioRisorse.CONNESSIONI_ALLOCATE_QUEUE_MANAGER.equals(this.methodName)) {
  872.                 String[] risorse = null;
  873.                 String[] risorseTransaction = null;
  874.                 String[] risorseStatistiche = null;
  875.                 String[] risorseConsegnePreseInCaricoSmistatore = null;
  876.                 String[] risorseConsegnePreseInCaricoRuntime = null;
  877.                 String[] risorseConsegnePreseInCaricoTransazioni = null;
  878.                 String[] risorseConsegneMessageBoxRuntime = null;
  879.                 String[] risorseConsegneMessageBoxTransazioni = null;
  880.                 if(this.list1!=null && !this.list1.isEmpty()) {
  881.                     risorse = this.list1.toArray(new String[1]);
  882.                 }
  883.                 if(this.list2!=null && !this.list2.isEmpty()) {
  884.                     risorseTransaction = this.list2.toArray(new String[1]);
  885.                 }
  886.                 if(this.list3!=null && !this.list3.isEmpty()) {
  887.                     risorseStatistiche = this.list3.toArray(new String[1]);
  888.                 }
  889.                 if(this.list4!=null && !this.list4.isEmpty()) {
  890.                     risorseConsegnePreseInCaricoSmistatore = this.list4.toArray(new String[1]);
  891.                 }
  892.                 if(this.list5!=null && !this.list5.isEmpty()) {
  893.                     risorseConsegnePreseInCaricoRuntime = this.list5.toArray(new String[1]);
  894.                 }
  895.                 if(this.list6!=null && !this.list6.isEmpty()) {
  896.                     risorseConsegnePreseInCaricoTransazioni = this.list6.toArray(new String[1]);
  897.                 }
  898.                 if(this.list7!=null && !this.list7.isEmpty()) {
  899.                     risorseConsegneMessageBoxRuntime = this.list7.toArray(new String[1]);
  900.                 }
  901.                 if(this.list8!=null && !this.list8.isEmpty()) {
  902.                     risorseConsegneMessageBoxTransazioni = this.list8.toArray(new String[1]);
  903.                 }
  904.                 if(MonitoraggioRisorse.CONNESSIONI_ALLOCATE_DB_MANAGER.equals(this.methodName)) {
  905.                     content =  MonitoraggioRisorse.getResultUsedDBConnections(risorse, risorseTransaction, risorseStatistiche,
  906.                             risorseConsegnePreseInCaricoSmistatore, risorseConsegnePreseInCaricoRuntime, risorseConsegnePreseInCaricoTransazioni,
  907.                             risorseConsegneMessageBoxRuntime, risorseConsegneMessageBoxTransazioni);
  908.                 }
  909.                 else if(MonitoraggioRisorse.CONNESSIONI_ALLOCATE_QUEUE_MANAGER.equals(this.methodName)) {
  910.                     content =  MonitoraggioRisorse.getResultUsedQueueConnections(risorse);
  911.                 }
  912.             }
  913.             else if(MonitoraggioRisorse.TRANSAZIONI_ATTIVE_ID.equals(this.methodName)) {
  914.                 content =  MonitoraggioRisorse.getResultTransazioniAttiveId(this.list1);
  915.             }
  916.             else if(MonitoraggioRisorse.TRANSAZIONI_ATTIVE_ID_PROTOCOLLO.equals(this.methodName)) {
  917.                 content =  MonitoraggioRisorse.getResultTransazioniAttiveIdProtocollo(this.list1);
  918.             }
  919.             else if(MonitoraggioRisorse.CONNESSIONI_ALLOCATE_CONNETTORI_PD.equals(this.methodName)) {
  920.                 content =  MonitoraggioRisorse.getResultActiveConnections(this.list1);
  921.             }
  922.             else if(MonitoraggioRisorse.CONNESSIONI_ALLOCATE_CONNETTORI_PA.equals(this.methodName)) {
  923.                 content =  MonitoraggioRisorse.getResultActiveConnections(this.list1);
  924.             }
  925.         }
  926.         else if(Costanti.JMX_NAME_DATASOURCE_PDD.equals(this.resourceName)) {
  927.             String[] risorse = null;
  928.             if(this.list1!=null && !this.list1.isEmpty()) {
  929.                 risorse = this.list1.toArray(new String[1]);
  930.             }
  931.             content = JmxDataSource.getResultUsedDBConnections(risorse);
  932.         }
  933.         else if(CostantiPdD.JMX_LOAD_BALANCER.equals(this.resourceName) &&
  934.             this.list1!=null && !this.list1.isEmpty()) {
  935.             StringBuilder sb = new StringBuilder();
  936.             for (String l : this.list1) {
  937.                 if(sb.length()>0) {
  938.                     sb.append("\n");
  939.                 }
  940.                 sb.append(l);
  941.             }
  942.             content = sb.toString();
  943.         }
  944.         
  945.         if(content!=null) {
  946.             httpResponse.setContentType(HttpConstants.CONTENT_TYPE_PLAIN);
  947.             httpResponse.setContent(content.getBytes());
  948.         }
  949.         return httpResponse;
  950.     }

  952. }
Created with JaCoCo 0.8.8.202204050719