GestoreConsegnaApplicativi.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.ArrayList;
  25. import java.util.Iterator;
  26. import java.util.List;

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

  43. import org.openspcoop2.core.commons.CoreException;
  44. import org.openspcoop2.core.config.constants.CostantiConfigurazione;
  45. import org.openspcoop2.core.id.IDConnettore;
  46. import org.openspcoop2.pdd.config.ConfigurazionePdD;
  47. import org.openspcoop2.pdd.config.ConfigurazionePdDManager;
  48. import org.openspcoop2.pdd.config.ConfigurazionePdDReader;
  49. import org.openspcoop2.pdd.core.behaviour.built_in.load_balance.GestoreLoadBalancerCaching;
  50. import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;
  51. import org.openspcoop2.pdd.services.OpenSPCoop2Startup;
  52. import org.slf4j.Logger;


  55. /**
  56.  * Implementazione JMX per la gestione della Configurazione di OpenSPCoop
  57.  *   
  58.  * @author Poli Andrea (apoli@link.it)
  59.  * @author $Author$
  60.  * @version $Rev$, $Date$
  61.  */
  62. public class GestoreConsegnaApplicativi extends NotificationBroadcasterSupport implements DynamicMBean {

  64.     /** Nomi proprieta' */
  65.     public static final String MAX_LIFE_PRESA_IN_CONSEGNA = "maxlifePresaInConsegna";

  67.     /** Nomi metodi' */
  68.     public static final String THREAD_POOL_STATUS = "getThreadPoolStatus";
  69.     public static final String QUEUE_CONFIG = "getQueueConfig";
  70.     public static final String GET_APPLICATIVI_PRIORITARI = "getApplicativiPrioritari";
  71.     public static final String GET_CONNETTORI_PRIORITARI = "getConnettoriPrioritari";
  72.     public static final String UPDATE_CONNETTORI_PRIORITARI = "updateConnettoriPrioritari";
  73.     public static final String RESET_CONNETTORI_PRIORITARI = "resetConnettoriPrioritari";
  74.         
  75.     /** Attributi */
  76.     private boolean cacheAbilitata = false;
  77.     private int maxLifePresaInConsegna = -1;
  78.     
  79.     /** getAttribute */
  80.     @Override
  81.     public Object getAttribute(String attributeName) throws AttributeNotFoundException,MBeanException,ReflectionException{
  82.         
  83.         if( (attributeName==null) || (attributeName.equals("")) )
  84.             throw new IllegalArgumentException("Il nome dell'attributo e' nullo o vuoto");
  85.         
  86.         if(attributeName.equals(JMXUtils.CACHE_ATTRIBUTE_ABILITATA))
  87.             return this.cacheAbilitata;
  88.         
  89.         if(attributeName.equals(GestoreConsegnaApplicativi.MAX_LIFE_PRESA_IN_CONSEGNA))
  90.             return this.maxLifePresaInConsegna;
  91.         
  92.         throw new AttributeNotFoundException("Attributo "+attributeName+" non trovato");
  93.     }
  94.     
  95.     /** getAttributes */
  96.     @Override
  97.     public AttributeList getAttributes(String [] attributesNames){
  98.         
  99.         if(attributesNames==null)
  100.             throw new IllegalArgumentException("Array nullo");
  101.         
  102.         AttributeList list = new AttributeList();
  103.         for (int i=0; i<attributesNames.length; i++){
  104.             try{
  105.                 list.add(new Attribute(attributesNames[i],getAttribute(attributesNames[i])));
  106.             }catch(JMException ex){}
  107.         }
  108.         return list;
  109.     }
  110.     
  111.     /** setAttribute */
  112.     @Override
  113.     public void setAttribute(Attribute attribute) throws AttributeNotFoundException, InvalidAttributeValueException, MBeanException, ReflectionException{
  114.         
  115.         if( attribute==null )
  116.             throw new IllegalArgumentException("Il nome dell'attributo e' nullo");
  117.         
  118.         try{
  119.             
  120.             if(attribute.getName().equals(JMXUtils.CACHE_ATTRIBUTE_ABILITATA)){
  121.                 boolean v = (Boolean) attribute.getValue();
  122.                 if(v){
  123.                     // la cache DEVE essere abilitata
  124.                     if(!this.cacheAbilitata){
  125.                         this.abilitaCache();
  126.                     }
  127.                 }
  128.                 else{
  129.                     // la cache DEVE essere disabilitata
  130.                     if(this.cacheAbilitata){
  131.                         this.disabilitaCache();
  132.                     }
  133.                 }
  134.             }
  135.             
  136.             throw new AttributeNotFoundException("Attributo "+attribute.getName()+" non trovato");
  137.             
  138.         }catch(ClassCastException ce){
  139.             throw new InvalidAttributeValueException("il tipo "+attribute.getValue().getClass()+" dell'attributo "+attribute.getName()+" non e' valido");
  140.         }catch(JMException j){
  141.             throw new MBeanException(j);
  142.         }
  143.         
  144.     }
  145.     
  146.     /** setAttributes */
  147.     @Override
  148.     public AttributeList setAttributes(AttributeList list){
  149.         
  150.         if(list==null)
  151.             throw new IllegalArgumentException("Lista degli attributi e' nulla");
  152.         
  153.         AttributeList ret = new AttributeList();
  154.         Iterator<?> it = ret.iterator();
  155.         
  156.         while(it.hasNext()){
  157.             try{
  158.                 Attribute attribute = (Attribute) it.next();
  159.                 setAttribute(attribute);
  160.                 ret.add(attribute);
  161.             }catch(JMException ex){}
  162.         }
  163.         
  164.         return ret;
  165.         
  166.     }
  167.     
  168.     /** invoke */
  169.     @Override
  170.     public Object invoke(String actionName, Object[]params, String[]signature) throws MBeanException,ReflectionException{
  171.         
  172.         if( (actionName==null) || (actionName.equals("")) )
  173.             throw new IllegalArgumentException("Nessuna operazione definita");
  174.         
  175.         if(actionName.equals(JMXUtils.CACHE_METHOD_NAME_RESET)){
  176.             return this.resetCache();
  177.         }
  178.         
  179.         if(actionName.equals(JMXUtils.CACHE_METHOD_NAME_PRINT_STATS)){
  180.             return this.printStatCache();
  181.         }
  182.                 
  183.         if(actionName.equals(JMXUtils.CACHE_METHOD_NAME_DISABILITA)){
  184.             return this.disabilitaCacheConEsito();
  185.         }
  186.         
  187.         if(actionName.equals(JMXUtils.CACHE_METHOD_NAME_ABILITA)){
  188.             if(params.length != 4)
  189.                 throw new MBeanException(new Exception("["+JMXUtils.CACHE_METHOD_NAME_ABILITA+"] Lunghezza parametri non corretta: "+params.length));
  190.             
  191.             Long param1 = null;
  192.             if(params[0]!=null && !"".equals(params[0])){
  193.                 param1 = (Long)params[0];
  194.                 if(param1<0){
  195.                     param1 = null;
  196.                 }
  197.             }
  198.             
  199.             Boolean param2 = null;
  200.             if(params[1]!=null && !"".equals(params[1])){
  201.                 param2 = (Boolean)params[1];
  202.             }
  203.             
  204.             Long param3 = null;
  205.             if(params[2]!=null && !"".equals(params[2])){
  206.                 param3 = (Long)params[2];
  207.                 if(param3<0){
  208.                     param3 = null;
  209.                 }
  210.             }
  211.             
  212.             Long param4 = null;
  213.             if(params[3]!=null && !"".equals(params[3])){
  214.                 param4 = (Long)params[3];
  215.                 if(param4<0){
  216.                     param4 = null;
  217.                 }
  218.             }
  219.                     
  220.             return this.abilitaCache(param1, param2, param3, param4 );
  221.         }
  222.         
  223.         if(actionName.equals(JMXUtils.CACHE_METHOD_NAME_LIST_KEYS)){
  224.             return this.listKeysCache();
  225.         }
  226.         
  227.         if(actionName.equals(JMXUtils.CACHE_METHOD_NAME_GET_OBJECT)){
  228.             
  229.             if(params.length != 1)
  230.                 throw new MBeanException(new Exception("["+JMXUtils.CACHE_METHOD_NAME_GET_OBJECT+"] Lunghezza parametri non corretta: "+params.length));
  231.             
  232.             String param1 = null;
  233.             if(params[0]!=null && !"".equals(params[0])){
  234.                 param1 = (String)params[0];
  235.             }
  236.             
  237.             return this.getObjectCache(param1);
  238.         }
  239.         
  240.         if(actionName.equals(JMXUtils.CACHE_METHOD_NAME_REMOVE_OBJECT)){
  241.             
  242.             if(params.length != 1)
  243.                 throw new MBeanException(new Exception("["+JMXUtils.CACHE_METHOD_NAME_REMOVE_OBJECT+"] Lunghezza parametri non corretta: "+params.length));
  244.             
  245.             String param1 = null;
  246.             if(params[0]!=null && !"".equals(params[0])){
  247.                 param1 = (String)params[0];
  248.             }
  249.             
  250.             return this.removeObjectCache(param1);
  251.         }
  252.             
  253.         if(actionName.equals(THREAD_POOL_STATUS)){
  254.             
  255.             if(params.length > 1)
  256.                 throw new MBeanException(new Exception("["+THREAD_POOL_STATUS+"] Lunghezza parametri non corretta: "+params.length));
  257.             
  258.             if(params.length > 0) {
  259.                 
  260.                 String param1 = null;
  261.                 if(params[0]!=null && !"".equals(params[0])){
  262.                     param1 = (String)params[0];
  263.                 }
  264.                 
  265.                 return this.getThreadPoolStatus(param1);
  266.             }
  267.             else {
  268.                 return this.getThreadPoolStatus(CostantiConfigurazione.CODA_DEFAULT);
  269.             }
  270.         }
  271.         
  272.         if(actionName.equals(QUEUE_CONFIG)){
  273.             
  274.             if(params.length > 1)
  275.                 throw new MBeanException(new Exception("["+QUEUE_CONFIG+"] Lunghezza parametri non corretta: "+params.length));
  276.             
  277.             if(params.length > 0) {
  278.                 
  279.                 String param1 = null;
  280.                 if(params[0]!=null && !"".equals(params[0])){
  281.                     param1 = (String)params[0];
  282.                 }
  283.                 
  284.                 return this.getQueueConfig(param1);
  285.             }
  286.             else {
  287.                 return this.getQueueConfig(CostantiConfigurazione.CODA_DEFAULT);
  288.             }
  289.         }
  290.         
  291.         if(actionName.equals(GET_APPLICATIVI_PRIORITARI)){
  292.             
  293.             if(params.length > 1)
  294.                 throw new MBeanException(new Exception("["+QUEUE_CONFIG+"] Lunghezza parametri non corretta: "+params.length));
  295.             
  296.             if(params.length > 0) {
  297.                 
  298.                 String param1 = null;
  299.                 if(params[0]!=null && !"".equals(params[0])){
  300.                     param1 = (String)params[0];
  301.                 }
  302.                 
  303.                 return this.getApplicativiPrioritari(param1);
  304.             }
  305.             else {
  306.                 return this.getApplicativiPrioritari(CostantiConfigurazione.CODA_DEFAULT);
  307.             }
  308.         }
  309.         
  310.         if(actionName.equals(GET_CONNETTORI_PRIORITARI)){
  311.             
  312.             if(params.length > 1)
  313.                 throw new MBeanException(new Exception("["+QUEUE_CONFIG+"] Lunghezza parametri non corretta: "+params.length));
  314.             
  315.             if(params.length > 0) {
  316.                 
  317.                 String param1 = null;
  318.                 if(params[0]!=null && !"".equals(params[0])){
  319.                     param1 = (String)params[0];
  320.                 }
  321.                 
  322.                 return this.getConnettoriPrioritari(param1);
  323.             }
  324.             else {
  325.                 return this.getConnettoriPrioritari(CostantiConfigurazione.CODA_DEFAULT);
  326.             }
  327.         }
  328.         
  329.         if(actionName.equals(UPDATE_CONNETTORI_PRIORITARI)){
  330.             
  331.             if(params.length > 1)
  332.                 throw new MBeanException(new Exception("["+QUEUE_CONFIG+"] Lunghezza parametri non corretta: "+params.length));
  333.             
  334.             if(params.length > 0) {
  335.                 
  336.                 String param1 = null;
  337.                 if(params[0]!=null && !"".equals(params[0])){
  338.                     param1 = (String)params[0];
  339.                 }
  340.                 
  341.                 return this.updateConnettoriPrioritari(param1);
  342.             }
  343.             else {
  344.                 return this.updateConnettoriPrioritari(CostantiConfigurazione.CODA_DEFAULT);
  345.             }
  346.         }
  347.         
  348.         if(actionName.equals(RESET_CONNETTORI_PRIORITARI)){
  349.             
  350.             if(params.length > 1)
  351.                 throw new MBeanException(new Exception("["+QUEUE_CONFIG+"] Lunghezza parametri non corretta: "+params.length));
  352.             
  353.             if(params.length > 0) {
  354.                 
  355.                 String param1 = null;
  356.                 if(params[0]!=null && !"".equals(params[0])){
  357.                     param1 = (String)params[0];
  358.                 }
  359.                 
  360.                 return this.resetConnettoriPrioritari(param1);
  361.             }
  362.             else {
  363.                 return this.resetConnettoriPrioritari(CostantiConfigurazione.CODA_DEFAULT);
  364.             }
  365.         }
  366.                 
  367.         throw new UnsupportedOperationException("Operazione "+actionName+" sconosciuta");
  368.     }
  369.     
  370.     /* MBean info */
  371.     @Override
  372.     public MBeanInfo getMBeanInfo(){
  373.                 
  374.         // Descrizione della classe nel MBean
  375.         String className = this.getClass().getName();
  376.         String description = "Risorsa per la configurazione ("+this.openspcoopProperties.getVersione()+")";

  378.         // MetaData per l'attributo abilitaCache
  379.         MBeanAttributeInfo cacheAbilitataVAR = JMXUtils.MBEAN_ATTRIBUTE_INFO_CACHE_ABILITATA;

  381.         // MetaData per l'attributo maxLife
  382.         MBeanAttributeInfo maxLife 
  383.             = new MBeanAttributeInfo(GestoreConsegnaApplicativi.MAX_LIFE_PRESA_IN_CONSEGNA,String.class.getName(),
  384.                         "Tempo massimo (in secondi) che un messaggio può essere tenuto in consegna da parte del gestore",
  385.                             JMXUtils.JMX_ATTRIBUTE_READABLE,!JMXUtils.JMX_ATTRIBUTE_WRITABLE,!JMXUtils.JMX_ATTRIBUTE_IS_GETTER);
  386.                 
  387.         // MetaData per l'operazione resetCache
  388.         MBeanOperationInfo resetCacheOP = JMXUtils.MBEAN_OPERATION_RESET_CACHE;
  389.         
  390.         // MetaData per l'operazione printStatCache
  391.         MBeanOperationInfo printStatCacheOP = JMXUtils.MBEAN_OPERATION_PRINT_STATS_CACHE;
  392.         
  393.         // MetaData per l'operazione disabilitaCache
  394.         MBeanOperationInfo disabilitaCacheOP = JMXUtils.MBEAN_OPERATION_DISABILITA_CACHE;
  395.         
  396.         // MetaData per l'operazione abilitaCache con parametri
  397.         MBeanOperationInfo abilitaCacheParametriOP = JMXUtils.MBEAN_OPERATION_ABILITA_CACHE_CON_PARAMETRI;
  398.         
  399.         // MetaData per l'operazione listKeysCache
  400.         MBeanOperationInfo listKeysCacheOP = JMXUtils.MBEAN_OPERATION_LIST_KEYS_CACHE; 

  402.         // MetaData per l'operazione getObjectCache
  403.         MBeanOperationInfo getObjectCacheOP = JMXUtils.MBEAN_OPERATION_GET_OBJECT_CACHE;
  404.         
  405.         // MetaData per l'operazione removeObjectCache
  406.         MBeanOperationInfo removeObjectCacheOP = JMXUtils.MBEAN_OPERATION_REMOVE_OBJECT_CACHE;
  407.                 
  408.         // MetaData per l'operazione threadPoolStatus
  409.         MBeanOperationInfo threadPoolStatusDefault 
  410.         = new MBeanOperationInfo(THREAD_POOL_STATUS,"Stato dei thread utilizzati per la consegna dei messaggi nella coda di default",
  411.             null,
  412.             String.class.getName(),
  413.             MBeanOperationInfo.ACTION);
  414.         
  415.         // MetaData per l'operazione threadPoolStatus
  416.         MBeanOperationInfo threadPoolStatus 
  417.         = new MBeanOperationInfo(THREAD_POOL_STATUS,"Stato dei thread utilizzati per la consegna dei messaggi nella coda indicata",
  418.             new MBeanParameterInfo[]{
  419.                     new MBeanParameterInfo("coda",String.class.getName(),"Nome della coda"),
  420.             },
  421.             String.class.getName(),
  422.             MBeanOperationInfo.ACTION);
  423.         
  424.         // MetaData per l'operazione threadPoolStatus
  425.         MBeanOperationInfo queueConfigDefault 
  426.         = new MBeanOperationInfo(QUEUE_CONFIG,"Configurazione della coda di default",
  427.             null,
  428.             String.class.getName(),
  429.             MBeanOperationInfo.ACTION);
  430.         
  431.         // MetaData per l'operazione threadPoolStatus
  432.         MBeanOperationInfo queueConfig 
  433.         = new MBeanOperationInfo(QUEUE_CONFIG,"Configurazione della coda indicata",
  434.             new MBeanParameterInfo[]{
  435.                     new MBeanParameterInfo("coda",String.class.getName(),"Nome della coda"),
  436.             },
  437.             String.class.getName(),
  438.             MBeanOperationInfo.ACTION);
  439.         
  440.         // MetaData per l'operazione getApplicativiPrioritariDefault
  441.         MBeanOperationInfo getApplicativiPrioritariDefault 
  442.         = new MBeanOperationInfo(GET_APPLICATIVI_PRIORITARI,"Applicativi configurati come prioritari nella coda di default",
  443.             null,
  444.             String.class.getName(),
  445.             MBeanOperationInfo.ACTION);
  446.         
  447.         // MetaData per l'operazione getApplicativiPrioritari
  448.         MBeanOperationInfo getApplicativiPrioritari
  449.         = new MBeanOperationInfo(GET_APPLICATIVI_PRIORITARI,"Applicativi configurati come prioritari nella coda indicata",
  450.             new MBeanParameterInfo[]{
  451.                     new MBeanParameterInfo("coda",String.class.getName(),"Nome della coda"),
  452.             },
  453.             String.class.getName(),
  454.             MBeanOperationInfo.ACTION);
  455.         
  456.         // MetaData per l'operazione getConnettoriPrioritariDefault
  457.         MBeanOperationInfo getConnettoriPrioritariDefault 
  458.         = new MBeanOperationInfo(GET_CONNETTORI_PRIORITARI,"Connettori configurati come prioritari nella coda di default",
  459.             null,
  460.             String.class.getName(),
  461.             MBeanOperationInfo.ACTION);
  462.         
  463.         // MetaData per l'operazione getConnettoriPrioritari
  464.         MBeanOperationInfo getConnettoriPrioritari
  465.         = new MBeanOperationInfo(GET_CONNETTORI_PRIORITARI,"Connettori configurati come prioritari nella coda indicata",
  466.             new MBeanParameterInfo[]{
  467.                     new MBeanParameterInfo("coda",String.class.getName(),"Nome della coda"),
  468.             },
  469.             String.class.getName(),
  470.             MBeanOperationInfo.ACTION);
  471.         
  472.         // MetaData per l'operazione updateConnettoriPrioritariDefault
  473.         MBeanOperationInfo updateConnettoriPrioritariDefault 
  474.         = new MBeanOperationInfo(UPDATE_CONNETTORI_PRIORITARI,"Aggiorna la configurazione dei connettori configurati come prioritari nella coda di default",
  475.             null,
  476.             String.class.getName(),
  477.             MBeanOperationInfo.ACTION);
  478.         
  479.         // MetaData per l'operazione updateConnettoriPrioritari
  480.         MBeanOperationInfo updateConnettoriPrioritari
  481.         = new MBeanOperationInfo(UPDATE_CONNETTORI_PRIORITARI,"Aggiorna la configurazione dei connettori configurati come prioritari nella coda indicata",
  482.             new MBeanParameterInfo[]{
  483.                     new MBeanParameterInfo("coda",String.class.getName(),"Nome della coda"),
  484.             },
  485.             String.class.getName(),
  486.             MBeanOperationInfo.ACTION);
  487.         
  488.         // MetaData per l'operazione resetConnettoriPrioritariDefault
  489.         MBeanOperationInfo resetConnettoriPrioritariDefault 
  490.         = new MBeanOperationInfo(RESET_CONNETTORI_PRIORITARI,"Rimuove i connettori configurati come prioritari nella coda di default",
  491.             null,
  492.             String.class.getName(),
  493.             MBeanOperationInfo.ACTION);
  494.         
  495.         // MetaData per l'operazione resetConnettoriPrioritari
  496.         MBeanOperationInfo resetConnettoriPrioritari
  497.         = new MBeanOperationInfo(RESET_CONNETTORI_PRIORITARI,"Rimuove i connettori configurati come prioritari nella coda indicata",
  498.             new MBeanParameterInfo[]{
  499.                     new MBeanParameterInfo("coda",String.class.getName(),"Nome della coda"),
  500.             },
  501.             String.class.getName(),
  502.             MBeanOperationInfo.ACTION);
  503.         
  504.         // Mbean costruttore
  505.         MBeanConstructorInfo defaultConstructor = new MBeanConstructorInfo("Default Constructor","Crea e inizializza una nuova istanza del MBean",null);

  507.         // Lista attributi
  508.         MBeanAttributeInfo[] attributes = new MBeanAttributeInfo[]{cacheAbilitataVAR,maxLife};
  509.         
  510.         // Lista Costruttori
  511.         MBeanConstructorInfo[] constructors = new MBeanConstructorInfo[]{defaultConstructor};
  512.         
  513.         // Lista operazioni
  514.         List<MBeanOperationInfo> listOperation = new ArrayList<>();
  515.         listOperation.add(resetCacheOP);
  516.         listOperation.add(printStatCacheOP);
  517.         listOperation.add(disabilitaCacheOP);
  518.         listOperation.add(abilitaCacheParametriOP);
  519.         listOperation.add(listKeysCacheOP);
  520.         listOperation.add(getObjectCacheOP);
  521.         listOperation.add(removeObjectCacheOP);
  522.         listOperation.add(threadPoolStatusDefault);
  523.         listOperation.add(threadPoolStatus);
  524.         listOperation.add(queueConfigDefault);
  525.         listOperation.add(queueConfig);
  526.         listOperation.add(getApplicativiPrioritariDefault);
  527.         listOperation.add(getApplicativiPrioritari);
  528.         listOperation.add(getConnettoriPrioritariDefault);
  529.         listOperation.add(getConnettoriPrioritari);
  530.         listOperation.add(updateConnettoriPrioritariDefault);
  531.         listOperation.add(updateConnettoriPrioritari);
  532.         listOperation.add(resetConnettoriPrioritariDefault);
  533.         listOperation.add(resetConnettoriPrioritari);
  534.         MBeanOperationInfo[] operations = listOperation.toArray(new MBeanOperationInfo[1]);
  535.         
  536.         return new MBeanInfo(className,description,attributes,constructors,operations,null);
  537.     }
  538.     
  539.     /* Variabili per la gestione JMX */
  540.     private Logger log;
  541.     org.openspcoop2.pdd.config.OpenSPCoop2Properties openspcoopProperties = null;
  542.     
  543.     /* Costruttore */
  544.     public GestoreConsegnaApplicativi(){
  545.         this.log = OpenSPCoop2Logger.getLoggerOpenSPCoopCore();
  546.         this.openspcoopProperties = org.openspcoop2.pdd.config.OpenSPCoop2Properties.getInstance();
  547.                 
  548.         // Configurazione
  549.         try{
  550.             this.cacheAbilitata = GestoreLoadBalancerCaching.isCacheAbilitata();
  551.         }catch(Exception e){
  552.             this.log.error("Errore durante l'identificazione dello stato della cache");
  553.         }
  554.         
  555.         this.maxLifePresaInConsegna = this.openspcoopProperties.getTimerConsegnaContenutiApplicativiPresaInConsegnaMaxLife();

  557.     }
  558.     
  559.     public boolean isCacheAbilitata() {
  560.         return this.cacheAbilitata;
  561.     }
  562.     
  563.     /* Metodi di management JMX */
  564.     public String resetCache(){
  565.         try{
  566.             if(!this.cacheAbilitata)
  567.                 throw new CoreException("Cache non abilitata");
  568.             GestoreLoadBalancerCaching.resetCache();
  569.             return JMXUtils.MSG_RESET_CACHE_EFFETTUATO_SUCCESSO;
  570.         }catch(Exception e){
  571.             this.log.error(JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage(),e);
  572.             return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  573.         }
  574.     }
  575.     
  576.     public String printStatCache(){
  577.         try{
  578.             if(!this.cacheAbilitata)
  579.                 throw new CoreException("Cache non abilitata");
  580.             return GestoreLoadBalancerCaching.printStatsCache("\n");
  581.         }catch(Exception e){
  582.             this.log.error(JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage(),e);
  583.             return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  584.         }
  585.     }
  586.     
  587.     public void abilitaCache(){
  588.         try{
  589.             GestoreLoadBalancerCaching.abilitaCache();
  590.             this.cacheAbilitata = true;
  591.         }catch(Exception e){
  592.             this.log.error(e.getMessage(),e);
  593.         }
  594.     }

  596.     public String abilitaCache(Long dimensioneCache,Boolean algoritmoCacheLRU,Long itemIdleTime,Long itemLifeSecond){
  597.         try{
  598.             GestoreLoadBalancerCaching.abilitaCache(dimensioneCache,algoritmoCacheLRU,itemIdleTime,itemLifeSecond, OpenSPCoop2Logger.getLoggerOpenSPCoopCore());
  599.             this.cacheAbilitata = true;
  600.             return JMXUtils.MSG_ABILITAZIONE_CACHE_EFFETTUATA;
  601.         }catch(Exception e){
  602.             this.log.error(e.getMessage(),e);
  603.             return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  604.         }
  605.     }
  606.     
  607.     public void disabilitaCache() throws JMException{
  608.         try{
  609.             GestoreLoadBalancerCaching.disabilitaCache();
  610.             this.cacheAbilitata = false;
  611.         }catch(Exception e){
  612.             this.log.error(e.getMessage(),e);
  613.             throw new JMException(e.getMessage());
  614.         }
  615.     }
  616.     public String disabilitaCacheConEsito() {
  617.         try{
  618.             disabilitaCache();
  619.             return JMXUtils.MSG_DISABILITAZIONE_CACHE_EFFETTUATA;
  620.         }catch(Exception e){
  621.             this.log.error(e.getMessage(),e);
  622.             return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  623.         }
  624.     }
  625.     
  626.     public String listKeysCache(){
  627.         try{
  628.             if(this.cacheAbilitata==false)
  629.                 throw new CoreException("Cache non abilitata");
  630.             return GestoreLoadBalancerCaching.listKeysCache("\n");
  631.         }catch(Exception e){
  632.             this.log.error(JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage(),e);
  633.             return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  634.         }
  635.     }
  636.     
  637.     public String getObjectCache(String key){
  638.         try{
  639.             if(this.cacheAbilitata==false)
  640.                 throw new CoreException("Cache non abilitata");
  641.             return GestoreLoadBalancerCaching.getObjectCache(key);
  642.         }catch(Exception e){
  643.             this.log.error(JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage(),e);
  644.             return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  645.         }
  646.     }
  647.     
  648.     public String removeObjectCache(String key){
  649.         try{
  650.             if(this.cacheAbilitata==false)
  651.                 throw new CoreException("Cache non abilitata");
  652.             GestoreLoadBalancerCaching.removeObjectCache(key);
  653.             return JMXUtils.MSG_RIMOZIONE_CACHE_EFFETTUATA;
  654.         }catch(Exception e){
  655.             this.log.error(JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage(),e);
  656.             return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  657.         }
  658.     }
  659.     
  660.     public String getThreadPoolStatus(String queue) {
  661.         try{
  662.             if(OpenSPCoop2Startup.threadConsegnaContenutiApplicativiRefMap==null ||
  663.                     !OpenSPCoop2Startup.threadConsegnaContenutiApplicativiRefMap.containsKey(queue)) {
  664.                 throw new CoreException("Coda '"+queue+"' non esistente");
  665.             }
  666.             return OpenSPCoop2Startup.threadConsegnaContenutiApplicativiRefMap.get(queue).getThreadsImage();
  667.         }catch(Exception e){
  668.             this.log.error(e.getMessage(),e);
  669.             return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  670.         }
  671.     }
  672.     
  673.     public String getQueueConfig(String queue) {
  674.         try{
  675.             if(OpenSPCoop2Startup.threadConsegnaContenutiApplicativiRefMap==null ||
  676.                     !OpenSPCoop2Startup.threadConsegnaContenutiApplicativiRefMap.containsKey(queue)) {
  677.                 throw new CoreException("Coda '"+queue+"' non esistente");
  678.             }
  679.             return OpenSPCoop2Startup.threadConsegnaContenutiApplicativiRefMap.get(queue).getQueueConfig();
  680.         }catch(Exception e){
  681.             this.log.error(e.getMessage(),e);
  682.             return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  683.         }
  684.     }
  685.     
  686.     public String getApplicativiPrioritari(String queue) {
  687.         try{
  688.             if(OpenSPCoop2Startup.threadConsegnaContenutiApplicativiRefMap==null ||
  689.                     !OpenSPCoop2Startup.threadConsegnaContenutiApplicativiRefMap.containsKey(queue)) {
  690.                 throw new CoreException("Coda '"+queue+"' non esistente");
  691.             }
  692.             List<IDConnettore> list = ConfigurazionePdDManager.getInstance().getConnettoriConsegnaNotifichePrioritarie(queue);
  693.             if(list==null || list.isEmpty()) {
  694.                 return "";
  695.             }
  696.             else {
  697.                 StringBuilder sb = new StringBuilder();
  698.                 for (IDConnettore idConnettore : list) {
  699.                     if(sb.length()>0) {
  700.                         sb.append(", ");
  701.                     }
  702.                     sb.append(idConnettore.getNome()).append("@").append(idConnettore.getIdSoggettoProprietario().toString());
  703.                 }
  704.                 return sb.toString();
  705.             }
  706.         }catch(Exception e){
  707.             this.log.error(e.getMessage(),e);
  708.             return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  709.         }
  710.     }
  711.     
  712.     public String getConnettoriPrioritari(String queue) {
  713.         try{
  714.             if(OpenSPCoop2Startup.threadConsegnaContenutiApplicativiRefMap==null ||
  715.                     !OpenSPCoop2Startup.threadConsegnaContenutiApplicativiRefMap.containsKey(queue)) {
  716.                 throw new CoreException("Coda '"+queue+"' non esistente");
  717.             }
  718.             List<IDConnettore> list = ConfigurazionePdDManager.getInstance().getConnettoriConsegnaNotifichePrioritarie(queue);
  719.             if(list==null || list.isEmpty()) {
  720.                 return "";
  721.             }
  722.             else {
  723.                 StringBuilder sb = new StringBuilder();
  724.                 for (IDConnettore idConnettore : list) {
  725.                     if(sb.length()>0) {
  726.                         sb.append(", ");
  727.                     }
  728.                     sb.append(idConnettore.getNomeConnettore());
  729.                 }
  730.                 return sb.toString();
  731.             }
  732.         }catch(Exception e){
  733.             this.log.error(e.getMessage(),e);
  734.             return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  735.         }
  736.     }
  737.     
  738.     public String updateConnettoriPrioritari(String queue) {
  739.         try{
  740.             if(OpenSPCoop2Startup.threadConsegnaContenutiApplicativiRefMap==null ||
  741.                     !OpenSPCoop2Startup.threadConsegnaContenutiApplicativiRefMap.containsKey(queue)) {
  742.                 throw new CoreException("Coda '"+queue+"' non esistente");
  743.             }
  744.             
  745.             ConfigurazionePdDReader.removeObjectCache(ConfigurazionePdD.getKey_getConnettoriConsegnaNotifichePrioritarie(queue));
  746.             
  747.             return JMXUtils.MSG_OPERAZIONE_EFFETTUATA_SUCCESSO;
  748.         }catch(Exception e){
  749.             this.log.error(e.getMessage(),e);
  750.             return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  751.         }
  752.     }

  754.     public String resetConnettoriPrioritari(String queue) {
  755.         try{
  756.             if(OpenSPCoop2Startup.threadConsegnaContenutiApplicativiRefMap==null ||
  757.                     !OpenSPCoop2Startup.threadConsegnaContenutiApplicativiRefMap.containsKey(queue)) {
  758.                 throw new CoreException("Coda '"+queue+"' non esistente");
  759.             }
  760.             
  761.             ConfigurazionePdDManager.getInstance().resetConnettoriConsegnaNotifichePrioritarie(queue);
  762.             
  763.             ConfigurazionePdDReader.removeObjectCache(ConfigurazionePdD.getKey_getConnettoriConsegnaNotifichePrioritarie(queue));
  764.             
  765.             return JMXUtils.MSG_OPERAZIONE_EFFETTUATA_SUCCESSO;
  766.         }catch(Exception e){
  767.             this.log.error(e.getMessage(),e);
  768.             return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+e.getMessage();
  769.         }
  770.     }
  771. }
Created with JaCoCo 0.8.8.202204050719