EngineKeystoreCaching.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.openspcoop2.pdd.config.OpenSPCoop2Properties;
  41. import org.openspcoop2.pdd.core.keystore.GestoreKeystoreCaching;
  42. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  43. import org.slf4j.Logger;


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


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

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

  269.         // Lista attributi
  270.         MBeanAttributeInfo[] attributes = new MBeanAttributeInfo[]{cacheAbilitataVAR};
  271.         
  272.         // Lista Costruttori
  273.         MBeanConstructorInfo[] constructors = new MBeanConstructorInfo[]{defaultConstructor};
  274.         
  275.         // Lista operazioni
  276.         MBeanOperationInfo[] operations = new MBeanOperationInfo[]{resetCacheOP,printStatCacheOP,disabilitaCacheOP,abilitaCacheParametriOP,listKeysCacheOP,getObjectCacheOP,removeObjectCacheOP};
  277.         
  278.         return new MBeanInfo(className,description,attributes,constructors,operations,null);
  279.     }
  280.     
  281.     /* Variabili per la gestione JMX */
  282.     private Logger log;
  283.     
  284.     /* Costruttore */
  285.     public EngineKeystoreCaching(){
  286.         this.log = OpenSPCoop2Logger.getLoggerOpenSPCoopCore();
  287.                 
  288.         // Configurazione
  289.         this.cacheAbilitata = GestoreKeystoreCaching.isCacheAbilitata();
  290.             
  291.     }
  292.     
  293.     public boolean isCacheAbilitata() {
  294.         return this.cacheAbilitata;
  295.     }
  296.     
  297.     /* Metodi di management JMX */
  298.     public String resetCache(){
  299.         try{
  300.             if(this.cacheAbilitata==false)
  301.                 throw new Exception("Cache non abilitata");
  302.             GestoreKeystoreCaching.resetCache();
  303.             return JMXUtils.MSG_RESET_CACHE_EFFETTUATO_SUCCESSO;
  304.         }catch(Throwable e){
  305.             this.log.error(JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage(),e);
  306.             return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  307.         }
  308.     }
  309.     
  310.     public String printStatCache(){
  311.         try{
  312.             if(this.cacheAbilitata==false)
  313.                 throw new Exception("Cache non abilitata");
  314.             return GestoreKeystoreCaching.printStatsCache("\n");
  315.         }catch(Throwable e){
  316.             this.log.error(JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage(),e);
  317.             return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  318.         }
  319.     }
  320.     
  321.     public String abilitaCache(){
  322.         try{
  323.             GestoreKeystoreCaching.abilitaCache();
  324.             this.cacheAbilitata = true;
  325.             return JMXUtils.MSG_ABILITAZIONE_CACHE_EFFETTUATA;
  326.         }catch(Throwable e){
  327.             this.log.error(e.getMessage(),e);
  328.             return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  329.         }
  330.     }

  332.     public String abilitaCache(Long dimensioneCache,Boolean algoritmoCacheLRU,Long itemIdleTime,Long itemLifeSecond){
  333.         try{
  334.             GestoreKeystoreCaching.abilitaCache(dimensioneCache,algoritmoCacheLRU,itemIdleTime,itemLifeSecond, this.log);
  335.             this.cacheAbilitata = true;
  336.             return JMXUtils.MSG_ABILITAZIONE_CACHE_EFFETTUATA;
  337.         }catch(Throwable e){
  338.             this.log.error(e.getMessage(),e);
  339.             return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  340.         }
  341.     }
  342.     
  343.     public void disabilitaCache() throws JMException{
  344.         try{
  345.             GestoreKeystoreCaching.disabilitaCache();
  346.             this.cacheAbilitata = false;
  347.         }catch(Throwable e){
  348.             this.log.error(e.getMessage(),e);
  349.             throw new JMException(e.getMessage());
  350.         }
  351.     }
  352.     public String disabilitaCacheConEsito() {
  353.         try{
  354.             disabilitaCache();
  355.             return JMXUtils.MSG_DISABILITAZIONE_CACHE_EFFETTUATA;
  356.         }catch(Throwable e){
  357.             this.log.error(e.getMessage(),e);
  358.             return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  359.         }
  360.     }
  361.     
  362.     public String listKeysCache(){
  363.         try{
  364.             if(this.cacheAbilitata==false)
  365.                 throw new Exception("Cache non abilitata");
  366.             return GestoreKeystoreCaching.listKeysCache("\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 getObjectCache(String key){
  374.         try{
  375.             if(this.cacheAbilitata==false)
  376.                 throw new Exception("Cache non abilitata");
  377.             return GestoreKeystoreCaching.getObjectCache(key);
  378.         }catch(Throwable e){
  379.             this.log.error(JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage(),e);
  380.             return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  381.         }
  382.     }
  383.     
  384.     public String removeObjectCache(String key){
  385.         try{
  386.             if(this.cacheAbilitata==false)
  387.                 throw new Exception("Cache non abilitata");
  388.             GestoreKeystoreCaching.removeObjectCache(key);
  389.             return JMXUtils.MSG_RIMOZIONE_CACHE_EFFETTUATA;
  390.         }catch(Throwable e){
  391.             this.log.error(JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage(),e);
  392.             return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  393.         }
  394.     }

  396. }
Created with JaCoCo 0.8.8.202204050719