AbstractCacheJmx.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.utils.cache;

  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;


  41. /**
  42.  * CacheJmx
  43.  *   
  44.  * @author Poli Andrea (apoli@link.it)
  45.  * @author $Author$
  46.  * @version $Rev$, $Date$
  47.  */
  48. public abstract class AbstractCacheJmx extends NotificationBroadcasterSupport implements DynamicMBean {

  50.     public abstract AbstractCacheWrapper getCacheWrapper();
  51.     
  52.     public abstract String getJmxDescription();
  53.     
  54.     
  55.     
  56.     /** Nomi proprieta' */
  57.     public static final String CACHE_NAME = "cacheName";
  58.     
  59.     /** getAttribute */
  60.     @Override
  61.     public Object getAttribute(String attributeName) throws AttributeNotFoundException,MBeanException,ReflectionException{
  62.         
  63.         if( (attributeName==null) || (attributeName.equals("")) )
  64.             throw new IllegalArgumentException("Il nome dell'attributo e' nullo o vuoto");
  65.         
  66.         if(attributeName.equals(Constants.CACHE_ATTRIBUTE_ABILITATA))
  67.             return this.getCacheWrapper().isCacheEnabled();
  68.         
  69.         if(attributeName.equals(AbstractCacheJmx.CACHE_NAME))
  70.             return this.getCacheWrapper().getCacheName();
  71.         
  72.         throw new AttributeNotFoundException("Attribute "+attributeName+" not found");
  73.     }
  74.     
  75.     /** getAttributes */
  76.     @Override
  77.     public AttributeList getAttributes(String [] attributesNames){
  78.         
  79.         if(attributesNames==null)
  80.             throw new IllegalArgumentException("Attributes Names undefined");
  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.                 // ignore
  88.             }
  89.         }
  90.         return list;
  91.     }
  92.     
  93.     /** setAttribute */
  94.     @Override
  95.     public void setAttribute(Attribute attribute) throws AttributeNotFoundException, InvalidAttributeValueException, MBeanException, ReflectionException{
  96.         
  97.         if( attribute==null )
  98.             throw new IllegalArgumentException("Attribute name undefined");
  99.         
  100.         try{
  101.             
  102.             if(attribute.getName().equals(Constants.CACHE_ATTRIBUTE_ABILITATA)){
  103.                 boolean v = (Boolean) attribute.getValue();
  104.                 if(v){
  105.                     // la cache DEVE essere abilitata
  106.                     if(!this.getCacheWrapper().isCacheEnabled()){
  107.                         this.abilitaCache();
  108.                     }
  109.                 }
  110.                 else{
  111.                     // la cache DEVE essere disabilitata
  112.                     if(this.getCacheWrapper().isCacheEnabled()){
  113.                         this.disabilitaCache();
  114.                     }
  115.                 }
  116.             }
  117.                         
  118.             else
  119.                 throw new AttributeNotFoundException("Attributo "+attribute.getName()+" non trovato");
  120.             
  121.         }catch(ClassCastException ce){
  122.             throw new InvalidAttributeValueException("Type "+attribute.getValue().getClass()+" for attribute "+attribute.getName()+" is not valid");
  123.         }catch(JMException j){
  124.             throw new MBeanException(j);
  125.         }
  126.         
  127.     }
  128.     
  129.     /** setAttributes */
  130.     @Override
  131.     public AttributeList setAttributes(AttributeList list){
  132.         
  133.         if(list==null)
  134.             throw new IllegalArgumentException("Lista degli attributi e' nulla");
  135.         
  136.         AttributeList ret = new AttributeList();
  137.         Iterator<?> it = ret.iterator();
  138.         
  139.         while(it.hasNext()){
  140.             try{
  141.                 Attribute attribute = (Attribute) it.next();
  142.                 setAttribute(attribute);
  143.                 ret.add(attribute);
  144.             }catch(JMException ex){}
  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("Operation undefined");
  157.         
  158.         if(actionName.equals(Constants.CACHE_METHOD_NAME_RESET)){
  159.             return this.resetCache();
  160.         }
  161.         
  162.         if(actionName.equals(Constants.CACHE_METHOD_NAME_PRINT_STATS)){
  163.             return this.printStatCache();
  164.         }
  165.                 
  166.         if(actionName.equals(Constants.CACHE_METHOD_NAME_DISABILITA)){
  167.             return this.disabilitaCacheConEsito();
  168.         }
  169.                 
  170.         if(actionName.equals(Constants.CACHE_METHOD_NAME_ABILITA)){
  171.             if(params.length != 4)
  172.                 throw new MBeanException(new Exception("["+Constants.CACHE_METHOD_NAME_ABILITA+"] Parameter size uncorrect: "+params.length));
  173.             
  174.             Integer param1 = null;
  175.             if(params[0]!=null && !"".equals(params[0])){
  176.                 param1 = (Integer)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.             Integer param3 = null;
  188.             if(params[2]!=null && !"".equals(params[2])){
  189.                 param3 = (Integer)params[2];
  190.                 if(param3<0){
  191.                     param3 = null;
  192.                 }
  193.             }
  194.             
  195.             Integer param4 = null;
  196.             if(params[3]!=null && !"".equals(params[3])){
  197.                 param4 = (Integer)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(Constants.CACHE_METHOD_NAME_LIST_KEYS)){
  207.             return this.listKeysCache();
  208.         }
  209.         
  210.         if(actionName.equals(Constants.CACHE_METHOD_NAME_GET_OBJECT)){
  211.             
  212.             if(params.length != 1)
  213.                 throw new MBeanException(new Exception("["+Constants.CACHE_METHOD_NAME_GET_OBJECT+"] Parameter size uncorrect: "+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(Constants.CACHE_METHOD_NAME_REMOVE_OBJECT)){
  224.             
  225.             if(params.length != 1)
  226.                 throw new MBeanException(new Exception("["+Constants.CACHE_METHOD_NAME_REMOVE_OBJECT+"] Parameter size uncorrect: "+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("Operation "+actionName+" unknown");
  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 = this.getJmxDescription();
  246.         
  247.         // MetaData per l'attributo abilitaCache
  248.         MBeanAttributeInfo cacheAbilitataVAR = Constants.MBEAN_ATTRIBUTE_INFO_CACHE_ABILITATA;
  249.         
  250.         // MetaData per l'attributo registriServizi
  251.         MBeanAttributeInfo registriServiziVAR 
  252.             = new MBeanAttributeInfo(AbstractCacheJmx.CACHE_NAME,String[].class.getName(),
  253.                         "Elenco dei registri dei servizi utilizzati a RunTime dalla Porta di Dominio",
  254.                             Constants.JMX_ATTRIBUTE_READABLE,!Constants.JMX_ATTRIBUTE_WRITABLE,!Constants.JMX_ATTRIBUTE_IS_GETTER);
  255.         
  256.         // MetaData per l'operazione resetCache
  257.         MBeanOperationInfo resetCacheOP = Constants.MBEAN_OPERATION_RESET_CACHE;
  258.         
  259.         // MetaData per l'operazione printStatCache
  260.         MBeanOperationInfo printStatCacheOP = Constants.MBEAN_OPERATION_PRINT_STATS_CACHE;
  261.         
  262.         // MetaData per l'operazione disabilitaCache
  263.         MBeanOperationInfo disabilitaCacheOP = Constants.MBEAN_OPERATION_DISABILITA_CACHE;
  264.         
  265.         // MetaData per l'operazione abilitaCache con parametri
  266.         MBeanOperationInfo abilitaCacheParametriOP = Constants.MBEAN_OPERATION_ABILITA_CACHE_CON_PARAMETRI;
  267.         
  268.         // MetaData per l'operazione listKeysCache
  269.         MBeanOperationInfo listKeysCacheOP = Constants.MBEAN_OPERATION_LIST_KEYS_CACHE; 

  271.         // MetaData per l'operazione getObjectCache
  272.         MBeanOperationInfo getObjectCacheOP = Constants.MBEAN_OPERATION_GET_OBJECT_CACHE;
  273.         
  274.         // MetaData per l'operazione removeObjectCache
  275.         MBeanOperationInfo removeObjectCacheOP = Constants.MBEAN_OPERATION_REMOVE_OBJECT_CACHE;
  276.         
  277.         // Mbean costruttore
  278.         MBeanConstructorInfo defaultConstructor = new MBeanConstructorInfo("Default Constructor","New Instance of MBean",null);

  280.         // Lista attributi
  281.         MBeanAttributeInfo[] attributes = new MBeanAttributeInfo[]{cacheAbilitataVAR,registriServiziVAR};
  282.         
  283.         // Lista Costruttori
  284.         MBeanConstructorInfo[] constructors = new MBeanConstructorInfo[]{defaultConstructor};
  285.         
  286.         // Lista operazioni
  287.         MBeanOperationInfo[] operations = new MBeanOperationInfo[]{resetCacheOP,printStatCacheOP,disabilitaCacheOP,abilitaCacheParametriOP,listKeysCacheOP,getObjectCacheOP,removeObjectCacheOP};
  288.         
  289.         return new MBeanInfo(className,description,attributes,constructors,operations,null);
  290.     }
  291.     
  292.     /* Variabili per la gestione JMX */

  294.     /* Costruttore */
  295.     public AbstractCacheJmx(){
  296.     }
  297.     
  298.     
  299.     /* Metodi di management JMX */
  300.     public String resetCache(){
  301.         try{
  302.             if(this.getCacheWrapper().isCacheEnabled()==false)
  303.                 throw new Exception("Cache disabled");
  304.             this.getCacheWrapper().resetCache();
  305.             return Constants.MSG_RESET_CACHE_EFFETTUATO_SUCCESSO;
  306.         }catch(Throwable e){
  307.             this.getCacheWrapper().getLog().error(Constants.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage(),e);
  308.             return Constants.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  309.         }
  310.     }
  311.     
  312.     public String printStatCache(){
  313.         try{
  314.             if(this.getCacheWrapper().isCacheEnabled()==false)
  315.                 throw new Exception("Cache non abilitata");
  316.             return this.getCacheWrapper().printStatsCache("\n");
  317.         }catch(Throwable e){
  318.             this.getCacheWrapper().getLog().error(Constants.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage(),e);
  319.             return Constants.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  320.         }
  321.     }
  322.     
  323.     public void abilitaCache() throws JMException{
  324.         try{
  325.             this.getCacheWrapper().enableCache();
  326.         }catch(Throwable e){
  327.             this.getCacheWrapper().getLog().error(e.getMessage(),e);
  328.         }
  329.     }
  330.     
  331.     public String abilitaCache(Integer dimensioneCache,Boolean algoritmoCacheLRU,Integer itemIdleTime,Integer itemLifeSecond){
  332.         try{
  333.             this.getCacheWrapper().enableCache(dimensioneCache,algoritmoCacheLRU,itemIdleTime,itemLifeSecond);
  334.             return Constants.MSG_ABILITAZIONE_CACHE_EFFETTUATA;
  335.         }catch(Throwable e){
  336.             this.getCacheWrapper().getLog().error(e.getMessage(),e);
  337.             return Constants.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  338.         }
  339.     }
  340.         
  341.     
  342.     public void disabilitaCache() throws JMException{
  343.         try{
  344.             this.getCacheWrapper().disableCache();
  345.         }catch(Throwable e){
  346.             this.getCacheWrapper().getLog().error(e.getMessage(),e);
  347.             throw new JMException(e.getMessage());
  348.         }
  349.     }
  350.     public String disabilitaCacheConEsito() {
  351.         try{
  352.             disabilitaCache();
  353.             return Constants.MSG_DISABILITAZIONE_CACHE_EFFETTUATA;
  354.         }catch(Throwable e){
  355.             this.getCacheWrapper().getLog().error(e.getMessage(),e);
  356.             return Constants.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  357.         }
  358.     }
  359.     
  360.     public String listKeysCache(){
  361.         try{
  362.             if(this.getCacheWrapper().isCacheEnabled()==false)
  363.                 throw new Exception("Cache disabled");
  364.             return this.getCacheWrapper().listKeysCache("\n");
  365.         }catch(Throwable e){
  366.             this.getCacheWrapper().getLog().error(Constants.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage(),e);
  367.             return Constants.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  368.         }
  369.     }
  370.     
  371.     public String getObjectCache(String key){
  372.         try{
  373.             if(this.getCacheWrapper().isCacheEnabled()==false)
  374.                 throw new Exception("Cache disabled");
  375.             return this.getCacheWrapper().getObjectCache(key);
  376.         }catch(Throwable e){
  377.             this.getCacheWrapper().getLog().error(Constants.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage(),e);
  378.             return Constants.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  379.         }
  380.     }
  381.     
  382.     public String removeObjectCache(String key){
  383.         try{
  384.             if(this.getCacheWrapper().isCacheEnabled()==false)
  385.                 throw new Exception("Cache disabled");
  386.             return this.getCacheWrapper().removeObjectCache(key);
  387.         }catch(Throwable e){
  388.             this.getCacheWrapper().getLog().error(Constants.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage(),e);
  389.             return Constants.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  390.         }
  391.     }
  392.     
  393. }
Created with JaCoCo 0.8.8.202204050719