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


  22. package org.openspcoop2.pdd.core.jmx;

  24. import java.util.Iterator;

  26. import javax.management.Attribute;
  27. import javax.management.AttributeList;
  28. import javax.management.AttributeNotFoundException;
  29. import javax.management.DynamicMBean;
  30. import javax.management.InvalidAttributeValueException;
  31. import javax.management.JMException;
  32. import javax.management.MBeanAttributeInfo;
  33. import javax.management.MBeanConstructorInfo;
  34. import javax.management.MBeanException;
  35. import javax.management.MBeanInfo;
  36. import javax.management.MBeanOperationInfo;
  37. import javax.management.MBeanParameterInfo;
  38. import javax.management.NotificationBroadcasterSupport;
  39. import javax.management.ReflectionException;

  41. import org.slf4j.Logger;
  42. import org.openspcoop2.core.constants.TipoPdD;
  43. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  44. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;


  47. /**
  48.  * Implementazione JMX per la gestione dei dati della richiesta
  49.  *   
  50.  * @author Poli Andrea (apoli@link.it)
  51.  * @author $Author$
  52.  * @version $Rev$, $Date$
  53.  */
  54. public class GestoreRichieste extends NotificationBroadcasterSupport implements DynamicMBean {

  56.     public static final String CACHE_METHOD_NAME_REMOVE_DATI_CONTROLLO_TRAFFICO_GLOBALE = "removeRateLimitingGlobalConfigCache";
  57.     public static final String CACHE_METHOD_NAME_REMOVE_DATI_CONTROLLO_TRAFFICO_API = "removeRateLimitingAPIConfigCache";
  58.     
  59.     /** Attributi */
  60.     private boolean cacheAbilitata = false;
  61.     
  62.     /** getAttribute */
  63.     @Override
  64.     public Object getAttribute(String attributeName) throws AttributeNotFoundException,MBeanException,ReflectionException{
  65.         
  66.         if( (attributeName==null) || (attributeName.equals("")) )
  67.             throw new IllegalArgumentException("Il nome dell'attributo e' nullo o vuoto");
  68.         
  69.         if(attributeName.equals(JMXUtils.CACHE_ATTRIBUTE_ABILITATA))
  70.             return this.cacheAbilitata;
  71.         
  72.         throw new AttributeNotFoundException("Attributo "+attributeName+" non trovato");
  73.     }
  74.     
  75.     /** getAttributes */
  76.     @Override
  77.     public AttributeList getAttributes(String [] attributesNames){
  78.         
  79.         if(attributesNames==null)
  80.             throw new IllegalArgumentException("Array nullo");
  81.         
  82.         AttributeList list = new AttributeList();
  83.         for (int i=0; i<attributesNames.length; i++){
  84.             try{
  85.                 list.add(new Attribute(attributesNames[i],getAttribute(attributesNames[i])));
  86.             }catch(JMException ex){}
  87.         }
  88.         return list;
  89.     }
  90.     
  91.     /** setAttribute */
  92.     @Override
  93.     public void setAttribute(Attribute attribute) throws AttributeNotFoundException, InvalidAttributeValueException, MBeanException, ReflectionException{
  94.         
  95.         if( attribute==null )
  96.             throw new IllegalArgumentException("Il nome dell'attributo e' nullo");
  97.         
  98.         try{
  99.             
  100.             if(attribute.getName().equals(JMXUtils.CACHE_ATTRIBUTE_ABILITATA)){
  101.                 boolean v = (Boolean) attribute.getValue();
  102.                 if(v){
  103.                     // la cache DEVE essere abilitata
  104.                     if(!this.cacheAbilitata){
  105.                         this.abilitaCache();
  106.                     }
  107.                 }
  108.                 else{
  109.                     // la cache DEVE essere disabilitata
  110.                     if(this.cacheAbilitata){
  111.                         this.disabilitaCache();
  112.                     }
  113.                 }
  114.             }
  115.             
  116.             else
  117.                 throw new AttributeNotFoundException("Attributo "+attribute.getName()+" non trovato");
  118.             
  119.         }catch(ClassCastException ce){
  120.             throw new InvalidAttributeValueException("il tipo "+attribute.getValue().getClass()+" dell'attributo "+attribute.getName()+" non e' valido");
  121.         }catch(JMException j){
  122.             throw new MBeanException(j);
  123.         }
  124.         
  125.     }
  126.     
  127.     /** setAttributes */
  128.     @Override
  129.     public AttributeList setAttributes(AttributeList list){
  130.         
  131.         if(list==null)
  132.             throw new IllegalArgumentException("Lista degli attributi e' nulla");
  133.         
  134.         AttributeList ret = new AttributeList();
  135.         Iterator<?> it = ret.iterator();
  136.         
  137.         while(it.hasNext()){
  138.             try{
  139.                 Attribute attribute = (Attribute) it.next();
  140.                 setAttribute(attribute);
  141.                 ret.add(attribute);
  142.             }catch(JMException ex){}
  143.         }
  144.         
  145.         return ret;
  146.         
  147.     }
  148.     
  149.     /** invoke */
  150.     @Override
  151.     public Object invoke(String actionName, Object[]params, String[]signature) throws MBeanException,ReflectionException{
  152.         
  153.         if( (actionName==null) || (actionName.equals("")) )
  154.             throw new IllegalArgumentException("Nessuna operazione definita");
  155.         
  156.         if(actionName.equals(JMXUtils.CACHE_METHOD_NAME_RESET)){
  157.             return this.resetCache();
  158.         }
  159.         
  160.         if(actionName.equals(JMXUtils.CACHE_METHOD_NAME_PRINT_STATS)){
  161.             return this.printStatCache();
  162.         }
  163.         
  164.         if(actionName.equals(JMXUtils.CACHE_METHOD_NAME_DISABILITA)){
  165.             return this.disabilitaCacheConEsito();
  166.         }
  167.         
  168.         if(actionName.equals(JMXUtils.CACHE_METHOD_NAME_ABILITA)){
  169.             if(params.length != 4)
  170.                 throw new MBeanException(new Exception("[AbilitaCache] Lunghezza parametri non corretta: "+params.length));
  171.             
  172.             Long param1 = null;
  173.             if(params[0]!=null && !"".equals(params[0])){
  174.                 param1 = (Long)params[0];
  175.                 if(param1<0){
  176.                     param1 = null;
  177.                 }
  178.             }
  179.             
  180.             Boolean param2 = null;
  181.             if(params[1]!=null && !"".equals(params[1])){
  182.                 param2 = (Boolean)params[1];
  183.             }
  184.             
  185.             Long param3 = null;
  186.             if(params[2]!=null && !"".equals(params[2])){
  187.                 param3 = (Long)params[2];
  188.                 if(param3<0){
  189.                     param3 = null;
  190.                 }
  191.             }
  192.             
  193.             Long param4 = null;
  194.             if(params[3]!=null && !"".equals(params[3])){
  195.                 param4 = (Long)params[3];
  196.                 if(param4<0){
  197.                     param4 = null;
  198.                 }
  199.             }
  200.                     
  201.             return this.abilitaCache(param1, param2, param3, param4 );
  202.         }
  203.         
  204.         if(actionName.equals(JMXUtils.CACHE_METHOD_NAME_LIST_KEYS)){
  205.             return this.listKeysCache();
  206.         }
  207.         
  208.         if(actionName.equals(JMXUtils.CACHE_METHOD_NAME_GET_OBJECT)){
  209.             
  210.             if(params.length != 1)
  211.                 throw new MBeanException(new Exception("["+JMXUtils.CACHE_METHOD_NAME_GET_OBJECT+"] Lunghezza parametri non corretta: "+params.length));
  212.             
  213.             String param1 = null;
  214.             if(params[0]!=null && !"".equals(params[0])){
  215.                 param1 = (String)params[0];
  216.             }
  217.             
  218.             return this.getObjectCache(param1);
  219.         }
  220.         
  221.         if(actionName.equals(JMXUtils.CACHE_METHOD_NAME_REMOVE_OBJECT)){
  222.             
  223.             if(params.length != 1)
  224.                 throw new MBeanException(new Exception("["+JMXUtils.CACHE_METHOD_NAME_REMOVE_OBJECT+"] Lunghezza parametri non corretta: "+params.length));
  225.             
  226.             String param1 = null;
  227.             if(params[0]!=null && !"".equals(params[0])){
  228.                 param1 = (String)params[0];
  229.             }
  230.             
  231.             return this.removeObjectCache(param1);
  232.         }
  233.         
  234.         if(actionName.equals(CACHE_METHOD_NAME_REMOVE_DATI_CONTROLLO_TRAFFICO_GLOBALE)){
  235.             return this.removeRateLimitingGlobalConfigCache();
  236.         }
  237.         
  238.         if(actionName.equals(CACHE_METHOD_NAME_REMOVE_DATI_CONTROLLO_TRAFFICO_API)){
  239.             if(params.length != 2)
  240.                 throw new MBeanException(new Exception("["+CACHE_METHOD_NAME_REMOVE_DATI_CONTROLLO_TRAFFICO_API+"] Lunghezza parametri non corretta: "+params.length));
  241.             
  242.             TipoPdD param1 = null;
  243.             if(params[0]!=null && !"".equals(params[0])){
  244.                 String param1_tipo = (String)params[0];
  245.                 param1 = TipoPdD.toTipoPdD(param1_tipo);
  246.                 if(param1==null) {
  247.                     try {
  248.                         param1 = TipoPdD.valueOf(param1_tipo);
  249.                     }catch(Throwable t) {}
  250.                 }
  251.                 if(param1==null || (!TipoPdD.APPLICATIVA.equals(param1) && !TipoPdD.DELEGATA.equals(param1))) {
  252.                     throw new MBeanException(new Exception("["+CACHE_METHOD_NAME_REMOVE_DATI_CONTROLLO_TRAFFICO_API+"] Primo parametro ("+param1_tipo+") non corretto; valori ammessi: "+
  253.                             TipoPdD.APPLICATIVA.getTipo()+","+TipoPdD.DELEGATA.getTipo()));
  254.                 }
  255.             }
  256.             
  257.             String param2 = null;
  258.             if(params[1]!=null && !"".equals(params[1])){
  259.                 param2 = (String)params[1];
  260.             }
  261.                     
  262.             return this.removeRateLimitingAPIConfigCache(param1, param2);
  263.         }
  264.         
  265.         throw new UnsupportedOperationException("Operazione "+actionName+" sconosciuta");
  266.     }
  267.     
  268.     /* MBean info */
  269.     @Override
  270.     public MBeanInfo getMBeanInfo(){
  271.         
  272.         // Descrizione della classe nel MBean
  273.         String className = this.getClass().getName();
  274.         String description = "Configurazione dei dati di autenticazione ai servizi esposti ("+OpenSPCoop2Properties.getInstance().getVersione()+")";
  275.         
  276.         // MetaData per l'attributo abilitaCache
  277.         MBeanAttributeInfo cacheAbilitataVAR = JMXUtils.MBEAN_ATTRIBUTE_INFO_CACHE_ABILITATA;
  278.         
  279.         // MetaData per l'operazione resetCache
  280.         MBeanOperationInfo resetCacheOP = JMXUtils.MBEAN_OPERATION_RESET_CACHE;
  281.         
  282.         // MetaData per l'operazione printStatCache
  283.         MBeanOperationInfo printStatCacheOP = JMXUtils.MBEAN_OPERATION_PRINT_STATS_CACHE;
  284.         
  285.         // MetaData per l'operazione disabilitaCache
  286.         MBeanOperationInfo disabilitaCacheOP = JMXUtils.MBEAN_OPERATION_DISABILITA_CACHE;
  287.         
  288.         // MetaData per l'operazione abilitaCache con parametri
  289.         MBeanOperationInfo abilitaCacheParametriOP = JMXUtils.MBEAN_OPERATION_ABILITA_CACHE_CON_PARAMETRI;
  290.         
  291.         // MetaData per l'operazione listKeysCache
  292.         MBeanOperationInfo listKeysCacheOP = JMXUtils.MBEAN_OPERATION_LIST_KEYS_CACHE; 

  294.         // MetaData per l'operazione getObjectCache
  295.         MBeanOperationInfo getObjectCacheOP = JMXUtils.MBEAN_OPERATION_GET_OBJECT_CACHE;
  296.         
  297.         // MetaData per l'operazione removeObjectCache
  298.         MBeanOperationInfo removeObjectCacheOP = JMXUtils.MBEAN_OPERATION_REMOVE_OBJECT_CACHE;
  299.         
  300.         // MetaData per l'operazione removeRateLimitingGlobalConfigCache
  301.         MBeanOperationInfo removeRateLimitingGlobalConfigCache 
  302.         = new MBeanOperationInfo(CACHE_METHOD_NAME_REMOVE_DATI_CONTROLLO_TRAFFICO_GLOBALE,"Rimuove le informazioni riguardanti policy di controllo del traffico globali",
  303.             null,
  304.             String.class.getName(),
  305.             MBeanOperationInfo.ACTION);
  306.         
  307.         // MetaData per l'operazione removeRateLimitingGlobalConfigCache
  308.         MBeanOperationInfo removeRateLimitingAPIConfigCache 
  309.         = new MBeanOperationInfo(CACHE_METHOD_NAME_REMOVE_DATI_CONTROLLO_TRAFFICO_API,"Rimuove le informazioni riguardanti policy di controllo del traffico dell'erogazione/fruizione indicata",
  310.             new MBeanParameterInfo[]{
  311.                 new MBeanParameterInfo("tipoPdD",String.class.getName(),"Indicazione se il nome della porta indicato riguarda una porta delegata o applicativa"),
  312.                 new MBeanParameterInfo("nomePorta",String.class.getName(),"Nome porta"),
  313.             },
  314.             String.class.getName(),
  315.             MBeanOperationInfo.ACTION);
  316.         
  317.         // Mbean costruttore
  318.         MBeanConstructorInfo defaultConstructor = new MBeanConstructorInfo("Default Constructor","Crea e inizializza una nuova istanza del MBean",null);

  320.         // Lista attributi
  321.         MBeanAttributeInfo[] attributes = new MBeanAttributeInfo[]{cacheAbilitataVAR};
  322.         
  323.         // Lista Costruttori
  324.         MBeanConstructorInfo[] constructors = new MBeanConstructorInfo[]{defaultConstructor};
  325.         
  326.         // Lista operazioni
  327.         MBeanOperationInfo[] operations = new MBeanOperationInfo[]{resetCacheOP,printStatCacheOP,disabilitaCacheOP,abilitaCacheParametriOP,listKeysCacheOP,getObjectCacheOP,removeObjectCacheOP,
  328.                 removeRateLimitingGlobalConfigCache, removeRateLimitingAPIConfigCache};
  329.         
  330.         return new MBeanInfo(className,description,attributes,constructors,operations,null);
  331.     }
  332.     
  333.     /* Variabili per la gestione JMX */
  334.     private Logger log;
  335.     
  336.     /* Costruttore */
  337.     public GestoreRichieste(){
  338.         this.log = OpenSPCoop2Logger.getLoggerOpenSPCoopCore();
  339.                 
  340.         // Configurazione
  341.         this.cacheAbilitata = org.openspcoop2.pdd.core.GestoreRichieste.isCacheAbilitata();
  342.             
  343.     }
  344.     
  345.     public boolean isCacheAbilitata() {
  346.         return this.cacheAbilitata;
  347.     }
  348.     
  349.     /* Metodi di management JMX */
  350.     public String resetCache(){
  351.         try{
  352.             if(this.cacheAbilitata==false)
  353.                 throw new Exception("Cache non abilitata");
  354.             org.openspcoop2.pdd.core.GestoreRichieste.resetCache();
  355.             return JMXUtils.MSG_RESET_CACHE_EFFETTUATO_SUCCESSO;
  356.         }catch(Throwable e){
  357.             this.log.error(JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage(),e);
  358.             return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  359.         }
  360.     }
  361.     
  362.     public String printStatCache(){
  363.         try{
  364.             if(this.cacheAbilitata==false)
  365.                 throw new Exception("Cache non abilitata");
  366.             return org.openspcoop2.pdd.core.GestoreRichieste.printStatsCache("\n");
  367.         }catch(Throwable e){
  368.             this.log.error(JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage(),e);
  369.             return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  370.         }
  371.     }
  372.     
  373.     public String abilitaCache(){
  374.         try{
  375.             org.openspcoop2.pdd.core.GestoreRichieste.abilitaCache();
  376.             this.cacheAbilitata = true;
  377.             return JMXUtils.MSG_ABILITAZIONE_CACHE_EFFETTUATA;
  378.         }catch(Throwable e){
  379.             this.log.error(e.getMessage(),e);
  380.             return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  381.         }
  382.     }

  384.     public String abilitaCache(Long dimensioneCache,Boolean algoritmoCacheLRU,Long itemIdleTime,Long itemLifeSecond){
  385.         try{
  386.             org.openspcoop2.pdd.core.GestoreRichieste.abilitaCache(dimensioneCache,algoritmoCacheLRU,itemIdleTime,itemLifeSecond);
  387.             this.cacheAbilitata = true;
  388.             return JMXUtils.MSG_ABILITAZIONE_CACHE_EFFETTUATA;
  389.         }catch(Throwable e){
  390.             this.log.error(e.getMessage(),e);
  391.             return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  392.         }
  393.     }
  394.     
  395.     public void disabilitaCache() throws JMException{
  396.         try{
  397.             org.openspcoop2.pdd.core.GestoreRichieste.disabilitaCache();
  398.             this.cacheAbilitata = false;
  399.         }catch(Throwable e){
  400.             this.log.error(e.getMessage(),e);
  401.             throw new JMException(e.getMessage());
  402.         }
  403.     }
  404.     public String disabilitaCacheConEsito() {
  405.         try{
  406.             disabilitaCache();
  407.             return JMXUtils.MSG_DISABILITAZIONE_CACHE_EFFETTUATA;
  408.         }catch(Throwable e){
  409.             this.log.error(e.getMessage(),e);
  410.             return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  411.         }
  412.     }
  413.     
  414.     public String listKeysCache(){
  415.         try{
  416.             if(this.cacheAbilitata==false)
  417.                 throw new Exception("Cache non abilitata");
  418.             return org.openspcoop2.pdd.core.GestoreRichieste.listKeysCache("\n");
  419.         }catch(Throwable e){
  420.             this.log.error(JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage(),e);
  421.             return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  422.         }
  423.     }
  424.     
  425.     public String getObjectCache(String key){
  426.         try{
  427.             if(this.cacheAbilitata==false)
  428.                 throw new Exception("Cache non abilitata");
  429.             return org.openspcoop2.pdd.core.GestoreRichieste.getObjectCache(key);
  430.         }catch(Throwable e){
  431.             this.log.error(JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage(),e);
  432.             return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  433.         }
  434.     }
  435.     
  436.     public String removeObjectCache(String key){
  437.         try{
  438.             if(this.cacheAbilitata==false)
  439.                 throw new Exception("Cache non abilitata");
  440.             org.openspcoop2.pdd.core.GestoreRichieste.removeObjectCache(key);
  441.             return JMXUtils.MSG_RIMOZIONE_CACHE_EFFETTUATA;
  442.         }catch(Throwable e){
  443.             this.log.error(JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage(),e);
  444.             return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  445.         }
  446.     }

  448.     public String removeRateLimitingGlobalConfigCache(){
  449.         try{
  450.             if(this.cacheAbilitata==false)
  451.                 throw new Exception("Cache non abilitata");
  452.             org.openspcoop2.pdd.core.GestoreRichieste.removeRateLimitingConfigGlobale();
  453.             return JMXUtils.MSG_RIMOZIONE_CACHE_EFFETTUATA;
  454.         }catch(Throwable e){
  455.             this.log.error(JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage(),e);
  456.             return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  457.         }
  458.     }
  459.     
  460.     public String removeRateLimitingAPIConfigCache(TipoPdD tipoPdD, String nomePorta){
  461.         try{
  462.             if(this.cacheAbilitata==false)
  463.                 throw new Exception("Cache non abilitata");
  464.             org.openspcoop2.pdd.core.GestoreRichieste.removeRateLimitingConfig(tipoPdD, nomePorta);
  465.             return JMXUtils.MSG_RIMOZIONE_CACHE_EFFETTUATA;
  466.         }catch(Throwable e){
  467.             this.log.error(JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage(),e);
  468.             return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  469.         }
  470.     }
  471.     
  472. }
Created with JaCoCo 0.8.8.202204050719