EngineGestioneToken.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.NotificationBroadcasterSupport;
  38. import javax.management.ReflectionException;

  40. import org.slf4j.Logger;
  41. import org.openspcoop2.core.commons.CoreException;
  42. import org.openspcoop2.pdd.config.OpenSPCoop2Properties;
  43. import org.openspcoop2.pdd.core.token.GestoreToken;
  44. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  45. import org.openspcoop2.utils.cache.Constants;


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

  57.     /** Attributi */
  58.     private boolean cacheAbilitata = false;
  59.     
  60.     /** getAttribute */
  61.     @Override
  62.     public Object getAttribute(String attributeName) throws AttributeNotFoundException,MBeanException,ReflectionException{
  63.         
  64.         if( (attributeName==null) || (attributeName.equals("")) )
  65.             throw new IllegalArgumentException("Il nome dell'attributo e' nullo o vuoto");
  66.         
  67.         if(attributeName.equals(JMXUtils.CACHE_ATTRIBUTE_ABILITATA))
  68.             return this.cacheAbilitata;
  69.         
  70.         throw new AttributeNotFoundException("Attributo "+attributeName+" non trovato");
  71.     }
  72.     
  73.     /** getAttributes */
  74.     @Override
  75.     public AttributeList getAttributes(String [] attributesNames){
  76.         
  77.         if(attributesNames==null)
  78.             throw new IllegalArgumentException("Array nullo");
  79.         
  80.         AttributeList list = new AttributeList();
  81.         for (int i=0; i<attributesNames.length; i++){
  82.             try{
  83.                 list.add(new Attribute(attributesNames[i],getAttribute(attributesNames[i])));
  84.             }catch(JMException ex){
  85.                 // ignore
  86.             }
  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.                 // ignore
  144.             }
  145.         }
  146.         
  147.         return ret;
  148.         
  149.     }
  150.     
  151.     /** invoke */
  152.     @Override
  153.     public Object invoke(String actionName, Object[]params, String[]signature) throws MBeanException,ReflectionException{
  154.         
  155.         if( (actionName==null) || (actionName.equals("")) )
  156.             throw new IllegalArgumentException("Nessuna operazione definita");
  157.         
  158.         if(actionName.equals(JMXUtils.CACHE_METHOD_NAME_RESET)){
  159.             return this.resetCache();
  160.         }
  161.         
  162.         if(actionName.equals(JMXUtils.CACHE_METHOD_NAME_PRINT_STATS)){
  163.             return this.printStatCache();
  164.         }
  165.         
  166.         if(actionName.equals(JMXUtils.CACHE_METHOD_NAME_DISABILITA)){
  167.             return this.disabilitaCacheConEsito();
  168.         }
  169.         
  170.         if(actionName.equals(JMXUtils.CACHE_METHOD_NAME_ABILITA)){
  171.             if(params.length != 4)
  172.                 throw new MBeanException(new Exception("[AbilitaCache] Lunghezza parametri non corretta: "+params.length));
  173.             
  174.             Long param1 = null;
  175.             if(params[0]!=null && !"".equals(params[0])){
  176.                 param1 = (Long)params[0];
  177.                 if(param1<0){
  178.                     param1 = null;
  179.                 }
  180.             }
  181.             
  182.             Boolean param2 = null;
  183.             if(params[1]!=null && !"".equals(params[1])){
  184.                 param2 = (Boolean)params[1];
  185.             }
  186.             
  187.             Long param3 = null;
  188.             if(params[2]!=null && !"".equals(params[2])){
  189.                 param3 = (Long)params[2];
  190.                 if(param3<0){
  191.                     param3 = null;
  192.                 }
  193.             }
  194.             
  195.             Long param4 = null;
  196.             if(params[3]!=null && !"".equals(params[3])){
  197.                 param4 = (Long)params[3];
  198.                 if(param4<0){
  199.                     param4 = null;
  200.                 }
  201.             }
  202.                     
  203.             return this.abilitaCache(param1, param2, param3, param4 );
  204.         }
  205.         
  206.         if(actionName.equals(JMXUtils.CACHE_METHOD_NAME_LIST_KEYS)){
  207.             return this.listKeysCache();
  208.         }
  209.         
  210.         if(actionName.equals(JMXUtils.CACHE_METHOD_NAME_GET_OBJECT)){
  211.             
  212.             if(params.length != 1)
  213.                 throw new MBeanException(new Exception("["+JMXUtils.CACHE_METHOD_NAME_GET_OBJECT+"] Lunghezza parametri non corretta: "+params.length));
  214.             
  215.             String param1 = null;
  216.             if(params[0]!=null && !"".equals(params[0])){
  217.                 param1 = (String)params[0];
  218.             }
  219.             
  220.             return this.getObjectCache(param1);
  221.         }
  222.         
  223.         if(actionName.equals(JMXUtils.CACHE_METHOD_NAME_REMOVE_OBJECT)){
  224.             
  225.             if(params.length != 1)
  226.                 throw new MBeanException(new Exception("["+JMXUtils.CACHE_METHOD_NAME_REMOVE_OBJECT+"] Lunghezza parametri non corretta: "+params.length));
  227.             
  228.             String param1 = null;
  229.             if(params[0]!=null && !"".equals(params[0])){
  230.                 param1 = (String)params[0];
  231.             }
  232.             
  233.             return this.removeObjectCache(param1);
  234.         }
  235.         
  236.         throw new UnsupportedOperationException("Operazione "+actionName+" sconosciuta");
  237.     }
  238.     
  239.     /* MBean info */
  240.     @Override
  241.     public MBeanInfo getMBeanInfo(){
  242.         
  243.         // Descrizione della classe nel MBean
  244.         String className = this.getClass().getName();
  245.         String description = "Gestione dei token transitati sul Gateway ("+OpenSPCoop2Properties.getInstance().getVersione()+")";
  246.         
  247.         // MetaData per l'attributo abilitaCache
  248.         MBeanAttributeInfo cacheAbilitataVAR = JMXUtils.MBEAN_ATTRIBUTE_INFO_CACHE_ABILITATA;
  249.         
  250.         // MetaData per l'operazione resetCache
  251.         MBeanOperationInfo resetCacheOP = JMXUtils.MBEAN_OPERATION_RESET_CACHE;
  252.         
  253.         // MetaData per l'operazione printStatCache
  254.         MBeanOperationInfo printStatCacheOP = JMXUtils.MBEAN_OPERATION_PRINT_STATS_CACHE;
  255.         
  256.         // MetaData per l'operazione disabilitaCache
  257.         MBeanOperationInfo disabilitaCacheOP = JMXUtils.MBEAN_OPERATION_DISABILITA_CACHE;
  258.         
  259.         // MetaData per l'operazione abilitaCache con parametri
  260.         MBeanOperationInfo abilitaCacheParametriOP = JMXUtils.MBEAN_OPERATION_ABILITA_CACHE_CON_PARAMETRI;
  261.         
  262.         // MetaData per l'operazione listKeysCache
  263.         MBeanOperationInfo listKeysCacheOP = JMXUtils.MBEAN_OPERATION_LIST_KEYS_CACHE; 

  265.         // MetaData per l'operazione getObjectCache
  266.         MBeanOperationInfo getObjectCacheOP = JMXUtils.MBEAN_OPERATION_GET_OBJECT_CACHE;
  267.         
  268.         // MetaData per l'operazione removeObjectCache
  269.         MBeanOperationInfo removeObjectCacheOP = JMXUtils.MBEAN_OPERATION_REMOVE_OBJECT_CACHE;
  270.         
  271.         // Mbean costruttore
  272.         MBeanConstructorInfo defaultConstructor = new MBeanConstructorInfo("Default Constructor","Crea e inizializza una nuova istanza del MBean",null);

  274.         // Lista attributi
  275.         MBeanAttributeInfo[] attributes = new MBeanAttributeInfo[]{cacheAbilitataVAR};
  276.         
  277.         // Lista Costruttori
  278.         MBeanConstructorInfo[] constructors = new MBeanConstructorInfo[]{defaultConstructor};
  279.         
  280.         // Lista operazioni
  281.         MBeanOperationInfo[] operations = new MBeanOperationInfo[]{resetCacheOP,printStatCacheOP,disabilitaCacheOP,abilitaCacheParametriOP,listKeysCacheOP,getObjectCacheOP,removeObjectCacheOP};
  282.         
  283.         return new MBeanInfo(className,description,attributes,constructors,operations,null);
  284.     }
  285.     
  286.     /* Variabili per la gestione JMX */
  287.     private Logger log;
  288.     private void logError(String msg, Throwable e) {
  289.         if(this.log!=null) {
  290.             this.log.error(msg,e);
  291.         }
  292.     }
  293.     
  294.     /* Costruttore */
  295.     public EngineGestioneToken(){
  296.         this.log = OpenSPCoop2Logger.getLoggerOpenSPCoopCore();
  297.                 
  298.         // Configurazione
  299.         this.cacheAbilitata = GestoreToken.isGestioneTokenCacheAbilitata();
  300.             
  301.     }
  302.     
  303.     public boolean isCacheAbilitata() {
  304.         return this.cacheAbilitata;
  305.     }
  306.     
  307.     /* Metodi di management JMX */
  308.     public String resetCache(){
  309.         try{
  310.             if(!this.cacheAbilitata)
  311.                 throw new CoreException(Constants.MSG_CACHE_NON_ABILITATA);
  312.             GestoreToken.resetGestioneTokenCache();
  313.             return JMXUtils.MSG_RESET_CACHE_EFFETTUATO_SUCCESSO;
  314.         }catch(Exception e){
  315.             this.logError(JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage(),e);
  316.             return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  317.         }
  318.     }
  319.     
  320.     public String printStatCache(){
  321.         try{
  322.             if(!this.cacheAbilitata)
  323.                 throw new CoreException(Constants.MSG_CACHE_NON_ABILITATA);
  324.             return GestoreToken.printStatsGestioneTokenCache("\n");
  325.         }catch(Exception e){
  326.             this.logError(JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage(),e);
  327.             return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  328.         }
  329.     }
  330.     
  331.     public String abilitaCache(){
  332.         try{
  333.             GestoreToken.abilitaGestioneTokenCache();
  334.             this.cacheAbilitata = true;
  335.             return JMXUtils.MSG_ABILITAZIONE_CACHE_EFFETTUATA;
  336.         }catch(Exception e){
  337.             this.logError(e.getMessage(),e);
  338.             return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  339.         }
  340.     }

  342.     public String abilitaCache(Long dimensioneCache,Boolean algoritmoCacheLRU,Long itemIdleTime,Long itemLifeSecond){
  343.         try{
  344.             GestoreToken.abilitaGestioneTokenCache(dimensioneCache,algoritmoCacheLRU,itemIdleTime,itemLifeSecond);
  345.             this.cacheAbilitata = true;
  346.             return JMXUtils.MSG_ABILITAZIONE_CACHE_EFFETTUATA;
  347.         }catch(Exception e){
  348.             this.logError(e.getMessage(),e);
  349.             return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  350.         }
  351.     }
  352.     
  353.     public void disabilitaCache() throws JMException{
  354.         try{
  355.             GestoreToken.disabilitaGestioneTokenCache();
  356.             this.cacheAbilitata = false;
  357.         }catch(Exception e){
  358.             this.logError(e.getMessage(),e);
  359.             throw new JMException(e.getMessage());
  360.         }
  361.     }
  362.     public String disabilitaCacheConEsito() {
  363.         try{
  364.             disabilitaCache();
  365.             return JMXUtils.MSG_DISABILITAZIONE_CACHE_EFFETTUATA;
  366.         }catch(Exception e){
  367.             this.logError(e.getMessage(),e);
  368.             return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  369.         }
  370.     }
  371.     
  372.     public String listKeysCache(){
  373.         try{
  374.             if(!this.cacheAbilitata)
  375.                 throw new CoreException(Constants.MSG_CACHE_NON_ABILITATA);
  376.             return GestoreToken.listKeysGestioneTokenCache("\n");
  377.         }catch(Exception e){
  378.             this.logError(JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage(),e);
  379.             return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  380.         }
  381.     }
  382.     
  383.     public String getObjectCache(String key){
  384.         try{
  385.             if(!this.cacheAbilitata)
  386.                 throw new CoreException(Constants.MSG_CACHE_NON_ABILITATA);
  387.             return GestoreToken.getObjectGestioneTokenCache(key);
  388.         }catch(Exception e){
  389.             this.logError(JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage(),e);
  390.             return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  391.         }
  392.     }
  393.     
  394.     public String removeObjectCache(String key){
  395.         try{
  396.             if(!this.cacheAbilitata)
  397.                 throw new CoreException(Constants.MSG_CACHE_NON_ABILITATA);
  398.             GestoreToken.removeObjectGestioneTokenCache(key);
  399.             return JMXUtils.MSG_RIMOZIONE_CACHE_EFFETTUATA;
  400.         }catch(Exception e){
  401.             this.logError(JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage(),e);
  402.             return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  403.         }
  404.     }

  406. }
Created with JaCoCo 0.8.8.202204050719