StatoServiziJMXResource.java

/*
 * GovWay - A customizable API Gateway 
 * https://govway.org
 * 
 * Copyright (c) 2005-2024 Link.it srl (https://link.it). 
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 3, as published by
 * the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */


package org.openspcoop2.pdd.core.jmx;


import java.util.Iterator;

import javax.management.Attribute;
import javax.management.AttributeList;
import javax.management.AttributeNotFoundException;
import javax.management.DynamicMBean;
import javax.management.InvalidAttributeValueException;
import javax.management.JMException;
import javax.management.MBeanAttributeInfo;
import javax.management.MBeanConstructorInfo;
import javax.management.MBeanException;
import javax.management.MBeanInfo;
import javax.management.MBeanOperationInfo;
import javax.management.MBeanParameterInfo;
import javax.management.NotificationBroadcasterSupport;
import javax.management.ReflectionException;

import org.openspcoop2.core.config.TipoFiltroAbilitazioneServizi;
import org.openspcoop2.core.config.constants.CostantiConfigurazione;
import org.openspcoop2.pdd.core.StatoServiziPdD;
import org.openspcoop2.pdd.logger.OpenSPCoop2Logger;


/**
 * Implementazione JMX per la gestione dell'autorizzazione
 *   
 * @author Poli Andrea (apoli@link.it)
 * @author $Author$
 * @version $Rev$, $Date$
 */
public class StatoServiziJMXResource extends NotificationBroadcasterSupport implements DynamicMBean {

	/** Nomi proprieta' */
	public static final String COMPONENTE_PD = "Servizio PortaDelegata";
	public static final String COMPONENTE_PD_ABILITAZIONI = "Servizio PortaDelegata (Abilitazioni Puntuali)";
	public static final String COMPONENTE_PD_DISABILITAZIONI = "Servizio PortaDelegata (Disabilitazioni Puntuali)";
	public static final String COMPONENTE_PA = "Servizio PortaApplicativa";
	public static final String COMPONENTE_PA_ABILITAZIONI = "Servizio PortaApplicativa (Abilitazioni Puntuali)";
	public static final String COMPONENTE_PA_DISABILITAZIONI = "Servizio PortaApplicativa (Disabilitazioni Puntuali)";
	public static final String COMPONENTE_IM = "Servizio IntegrationManager";

	/** Nomi metodi */
	public static final String ABILITA_COMPONENTE_PD = "abilitaServizioPortaDelegata"; 
	public static final String ABILITA_COMPONENTE_PA = "abilitaServizioPortaApplicativa"; 
	public static final String ABILITA_COMPONENTE_IM = "abilitaServizioIntegrationManager"; 
	public static final String ABILITA_SERVIZI = "abilitazioneCompletaServizi";

	public static final String DISABILITA_COMPONENTE_PD = "disabilitaServizioPortaDelegata"; 
	public static final String DISABILITA_COMPONENTE_PA = "disabilitaServizioPortaApplicativa"; 
	public static final String DISABILITA_COMPONENTE_IM = "disabilitaServizioIntegrationManager"; 
	public static final String DISABILITA_SERVIZI = "disabilitazioneCompletaServizi";

	public static final String ABILITA_ADD_FILTRO_ABILITAZIONE_PD = "addFiltroAbilitazioneServizioPortaDelegata";
	public static final String ABILITA_ADD_FILTRO_DISABILITAZIONE_PD = "addFiltroDisabilitazioneServizioPortaDelegata";
	public static final String ABILITA_ADD_FILTRO_ABILITAZIONE_PA = "addFiltroAbilitazioneServizioPortaApplicativa";
	public static final String ABILITA_ADD_FILTRO_DISABILITAZIONE_PA = "addFiltroDisabilitazioneServizioPortaApplicativa";

	public static final String ABILITA_REMOVE_FILTRO_ABILITAZIONE_PD = "removeFiltroAbilitazioneServizioPortaDelegata";
	public static final String ABILITA_REMOVE_FILTRO_DISABILITAZIONE_PD = "removeFiltroDisabilitazioneServizioPortaDelegata";
	public static final String ABILITA_REMOVE_FILTRO_ABILITAZIONE_PA = "removeFiltroAbilitazioneServizioPortaApplicativa";
	public static final String ABILITA_REMOVE_FILTRO_DISABILITAZIONE_PA = "removeFiltroDisabilitazioneServizioPortaApplicativa";



//	/** Attributi */
//	private String componentePD = CostantiConfigurazione.ABILITATO.getValue();
//	private String componentePD_abilitazioniPuntuali = "";
//	private String componentePD_disabilitazioniPuntuali = "";
//
//	private String componentePA = CostantiConfigurazione.ABILITATO.getValue();
//	private String componentePA_abilitazioniPuntuali = "";
//	private String componentePA_disabilitazioniPuntuali = "";
//
//	private String componenteIM = CostantiConfigurazione.ABILITATO.getValue();
	
	// uso anzi sempre la lettura effettiva, altrimenti si creano situazioni di stallo quando una cache della configurazione media il salvataggio reale
	public String getComponentePD(){
		return StatoServiziPdD.isPDServiceActive() ? CostantiConfigurazione.ABILITATO.getValue() : CostantiConfigurazione.DISABILITATO.getValue();
	}
	public String getComponentePD_abilitazioniPuntuali(){
		return visualizzaFiltriAbilitazioniServizioPortaDelegata();
	}
	public String getComponentePD_disabilitazioniPuntuali(){
		return visualizzaFiltriDisabilitazioniServizioPortaDelegata();
	}
	
	public String getComponentePA(){
		return StatoServiziPdD.isPAServiceActive() ? CostantiConfigurazione.ABILITATO.getValue() : CostantiConfigurazione.DISABILITATO.getValue();
	}
	public String getComponentePA_abilitazioniPuntuali(){
		return visualizzaFiltriAbilitazioniServizioPortaApplicativa();
	}
	public String getComponentePA_disabilitazioniPuntuali(){
		return visualizzaFiltriDisabilitazioniServizioPortaApplicativa();
	}
	
	public String getComponenteIM(){
		return StatoServiziPdD.isIMServiceActive() ? CostantiConfigurazione.ABILITATO.getValue() : CostantiConfigurazione.DISABILITATO.getValue();
	}



	/** getAttribute */
	@Override
	public Object getAttribute(String attributeName) throws AttributeNotFoundException,MBeanException,ReflectionException{

		if( (attributeName==null) || (attributeName.equals("")) )
			throw new IllegalArgumentException("Il nome dell'attributo e' nullo o vuoto");

		if(attributeName.equals(StatoServiziJMXResource.COMPONENTE_PD))
			return this.getComponentePD();
		else if(attributeName.equals(StatoServiziJMXResource.COMPONENTE_PD_ABILITAZIONI))
			return this.getComponentePD_abilitazioniPuntuali();
		else if(attributeName.equals(StatoServiziJMXResource.COMPONENTE_PD_DISABILITAZIONI))
			return this.getComponentePD_disabilitazioniPuntuali();

		else if(attributeName.equals(StatoServiziJMXResource.COMPONENTE_PA))
			return this.getComponentePA();
		else if(attributeName.equals(StatoServiziJMXResource.COMPONENTE_PA_ABILITAZIONI))
			return this.getComponentePA_abilitazioniPuntuali();
		else if(attributeName.equals(StatoServiziJMXResource.COMPONENTE_PA_DISABILITAZIONI))
			return this.getComponentePA_disabilitazioniPuntuali();

		else if(attributeName.equals(StatoServiziJMXResource.COMPONENTE_IM))
			return this.getComponenteIM();

		throw new AttributeNotFoundException("Attributo "+attributeName+" non trovato");
	}

	/** getAttributes */
	@Override
	public AttributeList getAttributes(String [] attributesNames){

		if(attributesNames==null)
			throw new IllegalArgumentException("Array nullo");

		AttributeList list = new AttributeList();
		for (int i=0; i<attributesNames.length; i++){
			try{
				list.add(new Attribute(attributesNames[i],getAttribute(attributesNames[i])));
			}catch(JMException ex){}
		}
		return list;
	}

	/** setAttribute */
	@Override
	public void setAttribute(Attribute attribute) throws AttributeNotFoundException, InvalidAttributeValueException, MBeanException, ReflectionException{

		if( attribute==null )
			throw new IllegalArgumentException("Il nome dell'attributo e' nullo");

		try{

			if(attribute.getName().equals(StatoServiziJMXResource.COMPONENTE_PD)){
				String v = (String) attribute.getValue();
				if(CostantiConfigurazione.ABILITATO.equals(v)){
					this.abilitaServizioPortaDelegata();
				}else{
					this.disabilitaServizioPortaDelegata();
				}
			}			
			else if(attribute.getName().equals(StatoServiziJMXResource.COMPONENTE_PA)){
				String v = (String) attribute.getValue();
				if(CostantiConfigurazione.ABILITATO.equals(v)){
					this.abilitaServizioPortaApplicativa();
				}else{
					this.disabilitaServizioPortaApplicativa();
				}
			}

			else if(attribute.getName().equals(StatoServiziJMXResource.COMPONENTE_IM)){
				String v = (String) attribute.getValue();
				if(CostantiConfigurazione.ABILITATO.equals(v)){
					this.abilitaServizioIntegrationManager();
				}else{
					this.disabilitaServizioIntegrationManager();
				}
			}

			else if(attribute.getName().equals(StatoServiziJMXResource.COMPONENTE_PD_ABILITAZIONI)){
				// nothing DO
			}
			else if(attribute.getName().equals(StatoServiziJMXResource.COMPONENTE_PD_DISABILITAZIONI)){
				// nothing DO
			}
			else if(attribute.getName().equals(StatoServiziJMXResource.COMPONENTE_PA_ABILITAZIONI)){
				// nothing DO
			}
			else if(attribute.getName().equals(StatoServiziJMXResource.COMPONENTE_PA_DISABILITAZIONI)){
				// nothing DO
			}

			else
				throw new AttributeNotFoundException("Attributo "+attribute.getName()+" non trovato");

		}catch(ClassCastException ce){
			throw new InvalidAttributeValueException("il tipo "+attribute.getValue().getClass()+" dell'attributo "+attribute.getName()+" non e' valido");
		}catch(JMException j){
			throw new MBeanException(j);
		}

	}

	/** setAttributes */
	@Override
	public AttributeList setAttributes(AttributeList list){

		if(list==null)
			throw new IllegalArgumentException("Lista degli attributi e' nulla");

		AttributeList ret = new AttributeList();
		Iterator<?> it = ret.iterator();

		while(it.hasNext()){
			try{
				Attribute attribute = (Attribute) it.next();
				setAttribute(attribute);
				ret.add(attribute);
			}catch(JMException ex){}
		}

		return ret;

	}

	/** invoke */
	@Override
	public Object invoke(String actionName, Object[]params, String[]signature) throws MBeanException,ReflectionException{

		if( (actionName==null) || (actionName.equals("")) )
			throw new IllegalArgumentException("Nessuna operazione definita");

		if(actionName.equals(StatoServiziJMXResource.ABILITA_COMPONENTE_PD)){
			return this.abilitaServizioPortaDelegata();
		}
		else if(actionName.equals(StatoServiziJMXResource.ABILITA_COMPONENTE_PA)){
			return this.abilitaServizioPortaApplicativa();
		}
		else if(actionName.equals(StatoServiziJMXResource.ABILITA_COMPONENTE_IM)){
			return this.abilitaServizioIntegrationManager();
		}
		else if(actionName.equals(StatoServiziJMXResource.ABILITA_SERVIZI)){
			return this.abilitazioneCompletaServizi();
		}

		else if(actionName.equals(StatoServiziJMXResource.DISABILITA_COMPONENTE_PD)){
			return this.disabilitaServizioPortaDelegata();
		}
		else if(actionName.equals(StatoServiziJMXResource.DISABILITA_COMPONENTE_PA)){
			return this.disabilitaServizioPortaApplicativa();
		}
		else if(actionName.equals(StatoServiziJMXResource.DISABILITA_COMPONENTE_IM)){
			return this.disabilitaServizioIntegrationManager();
		}
		else if(actionName.equals(StatoServiziJMXResource.DISABILITA_SERVIZI)){
			return this.disabilitazioneCompletaServizi();
		}

		else if(actionName.equals(StatoServiziJMXResource.ABILITA_ADD_FILTRO_ABILITAZIONE_PD)){
			if(params.length != 10)
				throw new MBeanException(new Exception("["+StatoServiziJMXResource.ABILITA_ADD_FILTRO_ABILITAZIONE_PD+"] Lunghezza parametri non corretta: "+params.length));
			return addFiltroAbilitazioneServizioPortaDelegata(getTipoFiltroAbilitazioneServizi(params));
		}
		else if(actionName.equals(StatoServiziJMXResource.ABILITA_ADD_FILTRO_DISABILITAZIONE_PD)){
			if(params.length != 10)
				throw new MBeanException(new Exception("["+StatoServiziJMXResource.ABILITA_ADD_FILTRO_DISABILITAZIONE_PD+"] Lunghezza parametri non corretta: "+params.length));
			return addFiltroDisabilitazioneServizioPortaDelegata(getTipoFiltroAbilitazioneServizi(params));
		}
		else if(actionName.equals(StatoServiziJMXResource.ABILITA_REMOVE_FILTRO_ABILITAZIONE_PD)){
			if(params.length != 10)
				throw new MBeanException(new Exception("["+StatoServiziJMXResource.ABILITA_REMOVE_FILTRO_ABILITAZIONE_PD+"] Lunghezza parametri non corretta: "+params.length));
			return removeFiltroAbilitazioneServizioPortaDelegata(getTipoFiltroAbilitazioneServizi(params));
		}
		else if(actionName.equals(StatoServiziJMXResource.ABILITA_REMOVE_FILTRO_DISABILITAZIONE_PD)){
			if(params.length != 10)
				throw new MBeanException(new Exception("["+StatoServiziJMXResource.ABILITA_REMOVE_FILTRO_DISABILITAZIONE_PD+"] Lunghezza parametri non corretta: "+params.length));
			return removeFiltroDisabilitazioneServizioPortaDelegata(getTipoFiltroAbilitazioneServizi(params));
		}

		else if(actionName.equals(StatoServiziJMXResource.ABILITA_ADD_FILTRO_ABILITAZIONE_PA)){
			if(params.length != 10)
				throw new MBeanException(new Exception("["+StatoServiziJMXResource.ABILITA_ADD_FILTRO_ABILITAZIONE_PA+"] Lunghezza parametri non corretta: "+params.length));
			return addFiltroAbilitazioneServizioPortaApplicativa(getTipoFiltroAbilitazioneServizi(params));
		}
		else if(actionName.equals(StatoServiziJMXResource.ABILITA_ADD_FILTRO_DISABILITAZIONE_PA)){
			if(params.length != 10)
				throw new MBeanException(new Exception("["+StatoServiziJMXResource.ABILITA_ADD_FILTRO_DISABILITAZIONE_PA+"] Lunghezza parametri non corretta: "+params.length));
			return addFiltroDisabilitazioneServizioPortaApplicativa(getTipoFiltroAbilitazioneServizi(params));
		}
		else if(actionName.equals(StatoServiziJMXResource.ABILITA_REMOVE_FILTRO_ABILITAZIONE_PA)){
			if(params.length != 10)
				throw new MBeanException(new Exception("["+StatoServiziJMXResource.ABILITA_REMOVE_FILTRO_ABILITAZIONE_PA+"] Lunghezza parametri non corretta: "+params.length));
			return removeFiltroAbilitazioneServizioPortaApplicativa(getTipoFiltroAbilitazioneServizi(params));
		}
		else if(actionName.equals(StatoServiziJMXResource.ABILITA_REMOVE_FILTRO_DISABILITAZIONE_PA)){
			if(params.length != 10)
				throw new MBeanException(new Exception("["+StatoServiziJMXResource.ABILITA_REMOVE_FILTRO_DISABILITAZIONE_PA+"] Lunghezza parametri non corretta: "+params.length));
			return removeFiltroDisabilitazioneServizioPortaApplicativa(getTipoFiltroAbilitazioneServizi(params));
		}

		throw new UnsupportedOperationException("Operazione "+actionName+" sconosciuta");
	}

	private TipoFiltroAbilitazioneServizi getTipoFiltroAbilitazioneServizi(Object [] params){
		TipoFiltroAbilitazioneServizi tipo = new TipoFiltroAbilitazioneServizi();

		int index = 0;

		String tmp = (String) params[index];
		if(tmp!=null && !"".equals(tmp)){
			tipo.setTipoSoggettoFruitore(tmp);
		}
		index++;
		tmp = (String) params[index];
		if(tmp!=null && !"".equals(tmp)){
			tipo.setSoggettoFruitore(tmp);
		}
		index++;
		tmp = (String) params[index];
		if(tmp!=null && !"".equals(tmp)){
			tipo.setIdentificativoPortaFruitore(tmp);
		}

		index++;
		tmp = (String) params[index];
		if(tmp!=null && !"".equals(tmp)){
			tipo.setTipoSoggettoErogatore(tmp);
		}
		index++;
		tmp = (String) params[index];
		if(tmp!=null && !"".equals(tmp)){
			tipo.setSoggettoErogatore(tmp);
		}
		index++;
		tmp = (String) params[index];
		if(tmp!=null && !"".equals(tmp)){
			tipo.setIdentificativoPortaErogatore(tmp);
		}

		index++;
		tmp = (String) params[index];
		if(tmp!=null && !"".equals(tmp)){
			tipo.setTipoServizio(tmp);
		}
		index++;
		tmp = (String) params[index];
		if(tmp!=null && !"".equals(tmp)){
			tipo.setServizio(tmp);
		}
		index++;
		Integer tmpI = (Integer) params[index];
		if(tmpI!=null){
			tipo.setVersioneServizio(tmpI);
		}

		index++;
		tmp = (String) params[index];
		if(tmp!=null && !"".equals(tmp)){
			tipo.setAzione(tmp);
		}

		return tipo;
	}

	/* MBean info */
	@Override
	public MBeanInfo getMBeanInfo(){

		// Descrizione della classe nel MBean
		String className = this.getClass().getName();
		String description = "Stato dei servizi attivi";

		// MetaData per gli attributi
		MBeanAttributeInfo componentePD_VAR 
		= new MBeanAttributeInfo(StatoServiziJMXResource.COMPONENTE_PD,String.class.getName(),
				"Indicazione se e' il servizio PortaDelegata risulta abilitato",
				JMXUtils.JMX_ATTRIBUTE_READABLE,JMXUtils.JMX_ATTRIBUTE_WRITABLE,!JMXUtils.JMX_ATTRIBUTE_IS_GETTER);
		MBeanAttributeInfo componentePD_abilitazioni_VAR 
		= new MBeanAttributeInfo(StatoServiziJMXResource.COMPONENTE_PD_ABILITAZIONI,String.class.getName(),
				"Filtri puntuali che abilitano l'utilizzo del servizio PortaDelegata",
				JMXUtils.JMX_ATTRIBUTE_READABLE,!JMXUtils.JMX_ATTRIBUTE_WRITABLE,!JMXUtils.JMX_ATTRIBUTE_IS_GETTER);
		MBeanAttributeInfo componentePD_disabilitazioni_VAR 
		= new MBeanAttributeInfo(StatoServiziJMXResource.COMPONENTE_PD_DISABILITAZIONI,String.class.getName(),
				"Filtri puntuali che disabilitano l'utilizzo del servizio PortaDelegata",
				JMXUtils.JMX_ATTRIBUTE_READABLE,!JMXUtils.JMX_ATTRIBUTE_WRITABLE,!JMXUtils.JMX_ATTRIBUTE_IS_GETTER);

		MBeanAttributeInfo componentePA_VAR 
		= new MBeanAttributeInfo(StatoServiziJMXResource.COMPONENTE_PA,String.class.getName(),
				"Indicazione se e' il servizio PortaApplicativa risulta abilitato",
				JMXUtils.JMX_ATTRIBUTE_READABLE,JMXUtils.JMX_ATTRIBUTE_WRITABLE,!JMXUtils.JMX_ATTRIBUTE_IS_GETTER);
		MBeanAttributeInfo componentePA_abilitazioni_VAR 
		= new MBeanAttributeInfo(StatoServiziJMXResource.COMPONENTE_PA_ABILITAZIONI,String.class.getName(),
				"Filtri puntuali che abilitano l'utilizzo del servizio PortaApplicativa",
				JMXUtils.JMX_ATTRIBUTE_READABLE,!JMXUtils.JMX_ATTRIBUTE_WRITABLE,!JMXUtils.JMX_ATTRIBUTE_IS_GETTER);
		MBeanAttributeInfo componentePA_disabilitazioni_VAR 
		= new MBeanAttributeInfo(StatoServiziJMXResource.COMPONENTE_PA_DISABILITAZIONI,String.class.getName(),
				"Filtri puntuali che disabilitano l'utilizzo del servizio PortaApplicativa",
				JMXUtils.JMX_ATTRIBUTE_READABLE,!JMXUtils.JMX_ATTRIBUTE_WRITABLE,!JMXUtils.JMX_ATTRIBUTE_IS_GETTER);

		MBeanAttributeInfo componenteIM_VAR 
		= new MBeanAttributeInfo(StatoServiziJMXResource.COMPONENTE_IM,String.class.getName(),
				"Indicazione se e' il servizio IntegrationManager risulta abilitato",
				JMXUtils.JMX_ATTRIBUTE_READABLE,JMXUtils.JMX_ATTRIBUTE_WRITABLE,!JMXUtils.JMX_ATTRIBUTE_IS_GETTER);


		// MetaData per le operazioni
		MBeanOperationInfo abilitaPD_OP 
		= new MBeanOperationInfo(StatoServiziJMXResource.ABILITA_COMPONENTE_PD,"Abilita il servizio PortaDelegata",
				null,
				String.class.getName(),
				MBeanOperationInfo.ACTION);
		MBeanOperationInfo abilitaPA_OP 
		= new MBeanOperationInfo(StatoServiziJMXResource.ABILITA_COMPONENTE_PA,"Abilita il servizio PortaApplicativa",
				null,
				String.class.getName(),
				MBeanOperationInfo.ACTION);
		MBeanOperationInfo abilitaIM_OP 
		= new MBeanOperationInfo(StatoServiziJMXResource.ABILITA_COMPONENTE_IM,"Abilita il servizio IntegrationManager",
				null,
				String.class.getName(),
				MBeanOperationInfo.ACTION);
		MBeanOperationInfo abilitazioneCompleta_OP 
		= new MBeanOperationInfo(StatoServiziJMXResource.ABILITA_SERVIZI,"Abilitazione completa di tutti i servizi",
				null,
				String.class.getName(),
				MBeanOperationInfo.ACTION);

		MBeanOperationInfo disabilitaPD_OP 
		= new MBeanOperationInfo(StatoServiziJMXResource.DISABILITA_COMPONENTE_PD,"Disabilita il servizio PortaDelegata",
				null,
				String.class.getName(),
				MBeanOperationInfo.ACTION);
		MBeanOperationInfo disabilitaPA_OP 
		= new MBeanOperationInfo(StatoServiziJMXResource.DISABILITA_COMPONENTE_PA,"Disabilita il servizio PortaApplicativa",
				null,
				String.class.getName(),
				MBeanOperationInfo.ACTION);
		MBeanOperationInfo disabilitaIM_OP 
		= new MBeanOperationInfo(StatoServiziJMXResource.DISABILITA_COMPONENTE_IM,"Disabilita il servizio IntegrationManager",
				null,
				String.class.getName(),
				MBeanOperationInfo.ACTION);
		MBeanOperationInfo disabilitazioneCompleta_OP 
		= new MBeanOperationInfo(StatoServiziJMXResource.DISABILITA_SERVIZI,"Disabilitazione completa di tutti i servizi",
				null,
				String.class.getName(),
				MBeanOperationInfo.ACTION);

		MBeanOperationInfo componentePD_addFiltroAbilitazione_VAR 
		= new MBeanOperationInfo(StatoServiziJMXResource.ABILITA_ADD_FILTRO_ABILITAZIONE_PD,"Aggiunge un filtro puntuale che abilita l'utilizzo del servizio PortaDelegata",
				getMBeanParameterInfoFiltroAbilitazioni(),
				String.class.getName(),
				MBeanOperationInfo.ACTION);		
		MBeanOperationInfo componentePD_addFiltroDisabilitazione_VAR 
		= new MBeanOperationInfo(StatoServiziJMXResource.ABILITA_ADD_FILTRO_DISABILITAZIONE_PD,"Aggiunge un filtro puntuale che disabilita l'utilizzo del servizio PortaDelegata",
				getMBeanParameterInfoFiltroAbilitazioni(),
				String.class.getName(),
				MBeanOperationInfo.ACTION);	
		MBeanOperationInfo componentePD_removeFiltroAbilitazione_VAR 
		= new MBeanOperationInfo(StatoServiziJMXResource.ABILITA_REMOVE_FILTRO_ABILITAZIONE_PD,"Rimuove un filtro puntuale che abilita l'utilizzo del servizio PortaDelegata",
				getMBeanParameterInfoFiltroAbilitazioni(),
				String.class.getName(),
				MBeanOperationInfo.ACTION);		
		MBeanOperationInfo componentePD_removeFiltroDisabilitazione_VAR 
		= new MBeanOperationInfo(StatoServiziJMXResource.ABILITA_REMOVE_FILTRO_DISABILITAZIONE_PD,"Rimuove un filtro puntuale che disabilita l'utilizzo del servizio PortaDelegata",
				getMBeanParameterInfoFiltroAbilitazioni(),
				String.class.getName(),
				MBeanOperationInfo.ACTION);	

		MBeanOperationInfo componentePA_addFiltroAbilitazione_VAR 
		= new MBeanOperationInfo(StatoServiziJMXResource.ABILITA_ADD_FILTRO_ABILITAZIONE_PA,"Aggiunge un filtro puntuale che abilita l'utilizzo del servizio PortaApplicativa",
				getMBeanParameterInfoFiltroAbilitazioni(),
				String.class.getName(),
				MBeanOperationInfo.ACTION);		
		MBeanOperationInfo componentePA_addFiltroDisabilitazione_VAR 
		= new MBeanOperationInfo(StatoServiziJMXResource.ABILITA_ADD_FILTRO_DISABILITAZIONE_PA,"Aggiunge un filtro puntuale che disabilita l'utilizzo del servizio PortaApplicativa",
				getMBeanParameterInfoFiltroAbilitazioni(),
				String.class.getName(),
				MBeanOperationInfo.ACTION);	
		MBeanOperationInfo componentePA_removeFiltroAbilitazione_VAR 
		= new MBeanOperationInfo(StatoServiziJMXResource.ABILITA_REMOVE_FILTRO_ABILITAZIONE_PA,"Rimuove un filtro puntuale che abilita l'utilizzo del servizio PortaApplicativa",
				getMBeanParameterInfoFiltroAbilitazioni(),
				String.class.getName(),
				MBeanOperationInfo.ACTION);		
		MBeanOperationInfo componentePA_removeFiltroDisabilitazione_VAR 
		= new MBeanOperationInfo(StatoServiziJMXResource.ABILITA_REMOVE_FILTRO_DISABILITAZIONE_PA,"Rimuove un filtro puntuale che disabilita l'utilizzo del servizio PortaApplicativa",
				getMBeanParameterInfoFiltroAbilitazioni(),
				String.class.getName(),
				MBeanOperationInfo.ACTION);	


		// Mbean costruttore
		MBeanConstructorInfo defaultConstructor = new MBeanConstructorInfo("Default Constructor","Crea e inizializza una nuova istanza del MBean",null);

		// Lista attributi
		MBeanAttributeInfo[] attributes = new MBeanAttributeInfo[]{componentePD_VAR,componentePD_abilitazioni_VAR,componentePD_disabilitazioni_VAR,
				componentePA_VAR,componentePA_abilitazioni_VAR,componentePA_disabilitazioni_VAR,
				componenteIM_VAR};

		// Lista Costruttori
		MBeanConstructorInfo[] constructors = new MBeanConstructorInfo[]{defaultConstructor};

		// Lista operazioni
		MBeanOperationInfo[] operations = new MBeanOperationInfo[]{abilitaPD_OP,abilitaPA_OP,abilitaIM_OP,abilitazioneCompleta_OP,
				disabilitaPD_OP,disabilitaPA_OP,disabilitaIM_OP,disabilitazioneCompleta_OP,
				componentePD_addFiltroAbilitazione_VAR,componentePD_addFiltroDisabilitazione_VAR,
				componentePD_removeFiltroAbilitazione_VAR,componentePD_removeFiltroDisabilitazione_VAR,
				componentePA_addFiltroAbilitazione_VAR,componentePA_addFiltroDisabilitazione_VAR,
				componentePA_removeFiltroAbilitazione_VAR,componentePA_removeFiltroDisabilitazione_VAR};

		return new MBeanInfo(className,description,attributes,constructors,operations,null);
	}


	private MBeanParameterInfo[] getMBeanParameterInfoFiltroAbilitazioni(){
		MBeanParameterInfo[] m = new MBeanParameterInfo[]{

				new MBeanParameterInfo("tipoSoggettoFruitore",String.class.getName(),"Tipo del soggetto fruitore"),
				new MBeanParameterInfo("nomeSoggettoFruitore",String.class.getName(),"Nome del soggetto fruitore"),
				new MBeanParameterInfo("identificativoPortaSoggettoFruitore",String.class.getName(),"Identificativo della PdD del soggetto fruitore"),

				new MBeanParameterInfo("tipoSoggettoErogatore",String.class.getName(),"Tipo del soggetto erogatore"),
				new MBeanParameterInfo("nomeSoggettoErogatore",String.class.getName(),"Nome del soggetto erogatore"),
				new MBeanParameterInfo("identificativoPortaSoggettoErogatore",String.class.getName(),"Identificativo della PdD del soggetto erogatore"),

				new MBeanParameterInfo("tipoServizio",String.class.getName(),"Tipo del servizio"),
				new MBeanParameterInfo("nomeServizio",String.class.getName(),"Nome del servizio"),
				new MBeanParameterInfo("versioneServizio",Integer.class.getName(),"Versione del servizio"),

				new MBeanParameterInfo("azione",String.class.getName(),"azione")
		};
		return m;
	}


	/* Costruttore */
	public StatoServiziJMXResource() {

		
	}

	/* Metodi di management JMX */

	public String abilitaServizioPortaDelegata(){
		if(CostantiConfigurazione.ABILITATO.equals(this.getComponentePD())){
			return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+" il servizio PortaDelegata risulta già abilitato";
		}else{
			try{
				StatoServiziPdD.setPDServiceActive(true);
				return "Abilitazione del servizio PortaDelegata effettuata con successo";
			}catch(Throwable e){
				OpenSPCoop2Logger.getLoggerOpenSPCoopCore().error("Abilitazione del servizio PortaDelegata non riuscita: "+e.getMessage(),e);
				return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+" sistema non disponibile";
			}
		}
	}
	public String abilitaServizioPortaApplicativa(){
		if(CostantiConfigurazione.ABILITATO.equals(this.getComponentePA())){
			return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+" il servizio PortaApplicativa risulta già abilitato";
		}else{
			try{
				StatoServiziPdD.setPAServiceActive(true);
				return "Abilitazione del servizio PortaApplicativa effettuata con successo";
			}catch(Throwable e){
				OpenSPCoop2Logger.getLoggerOpenSPCoopCore().error("Abilitazione del servizio PortaApplicativa non riuscita: "+e.getMessage(),e);
				return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+" sistema non disponibile";
			}
		}
	}
	public String abilitaServizioIntegrationManager(){
		if(CostantiConfigurazione.ABILITATO.equals(this.getComponenteIM())){
			return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+" il servizio IntegrationManager risulta già abilitato";
		}else{
			try{
				StatoServiziPdD.setIMServiceActive(true);
				return "Abilitazione del servizio IntegrationManager effettuata con successo";
			}catch(Throwable e){
				OpenSPCoop2Logger.getLoggerOpenSPCoopCore().error("Abilitazione del servizio IntegrationManager non riuscita: "+e.getMessage(),e);
				return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+" sistema non disponibile";
			}
		}
	}
	public String abilitazioneCompletaServizi(){
		StringBuilder bf = new StringBuilder();	
		bf.append(this.abilitaServizioPortaDelegata());	
		bf.append("; ");
		bf.append(this.abilitaServizioPortaApplicativa());	
		bf.append("; ");
		bf.append(this.abilitaServizioIntegrationManager());	
		return bf.toString();
	}




	public String disabilitaServizioPortaDelegata(){
		if(CostantiConfigurazione.DISABILITATO.equals(this.getComponentePD())){
			return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+" il servizio PortaDelegata risulta già disabilitato";
		}else{
			try{
				StatoServiziPdD.setPDServiceActive(false);
				return "Disabilitazione del servizio PortaDelegata effettuata con successo";
			}catch(Throwable e){
				OpenSPCoop2Logger.getLoggerOpenSPCoopCore().error("Disabilitazione del servizio PortaDelegata non riuscita: "+e.getMessage(),e);
				return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+" sistema non disponibile";
			}
		}
	}
	public String disabilitaServizioPortaApplicativa(){
		if(CostantiConfigurazione.DISABILITATO.equals(this.getComponentePA())){
			return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+" il servizio PortaApplicativa risulta già disabilitato";
		}else{
			try{
				StatoServiziPdD.setPAServiceActive(false);
				return "Disabilitazione del servizio PortaApplicativa effettuata con successo";
			}catch(Throwable e){
				OpenSPCoop2Logger.getLoggerOpenSPCoopCore().error("Disabilitazione del servizio PortaApplicativa non riuscita: "+e.getMessage(),e);
				return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+" sistema non disponibile";
			}
		}
	}
	public String disabilitaServizioIntegrationManager(){
		if(CostantiConfigurazione.DISABILITATO.equals(this.getComponenteIM())){
			return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+" il servizio IntegrationManager risulta già disabilitato";
		}else{
			try{
				StatoServiziPdD.setIMServiceActive(false);
				return "Disabilitazione del servizio IntegrationManager effettuata con successo";
			}catch(Throwable e){
				OpenSPCoop2Logger.getLoggerOpenSPCoopCore().error("Disabilitazione del servizio IntegrationManager non riuscita: "+e.getMessage(),e);
				return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+" sistema non disponibile";
			}
		}
	}
	public String disabilitazioneCompletaServizi(){
		StringBuilder bf = new StringBuilder();	
		bf.append(this.disabilitaServizioPortaDelegata());	
		bf.append("; ");
		bf.append(this.disabilitaServizioPortaApplicativa());	
		bf.append("; ");
		bf.append(this.disabilitaServizioIntegrationManager());	
		return bf.toString();
	}





	public String visualizzaFiltriAbilitazioniServizioPortaDelegata(){
		try{
			return StatoServiziPdD.getPDServiceFiltriAbilitazioneAttivi();
		}catch(Throwable e){
			OpenSPCoop2Logger.getLoggerOpenSPCoopCore().error("Operazione visualizzaFiltriAbilitazioniServizioPortaDelegata non riuscita: "+e.getMessage(),e);
			return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+" sistema non disponibile";
		}
	}
	public String visualizzaFiltriDisabilitazioniServizioPortaDelegata(){
		try{
			return StatoServiziPdD.getPDServiceFiltriDisabilitazioneAttivi();
		}catch(Throwable e){
			OpenSPCoop2Logger.getLoggerOpenSPCoopCore().error("Operazione visualizzaFiltriDisabilitazioniServizioPortaDelegata non riuscita: "+e.getMessage(),e);
			return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+" sistema non disponibile";
		}
	}
	public String addFiltroAbilitazioneServizioPortaDelegata(TipoFiltroAbilitazioneServizi tipo){
		try{
			StatoServiziPdD.addFiltroAbilitazionePD(tipo);
			return "Operazione effettuata con successo";
		}catch(Throwable e){
			OpenSPCoop2Logger.getLoggerOpenSPCoopCore().error("Operazione addFiltroAbilitazioneServizioPortaDelegata non riuscita: "+e.getMessage(),e);
			return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+" sistema non disponibile";
		}
	}
	public String addFiltroDisabilitazioneServizioPortaDelegata(TipoFiltroAbilitazioneServizi tipo){
		try{
			StatoServiziPdD.addFiltroDisabilitazionePD(tipo);
			return "Operazione effettuata con successo";
		}catch(Throwable e){
			OpenSPCoop2Logger.getLoggerOpenSPCoopCore().error("Operazione addFiltroDisabilitazioneServizioPortaDelegata non riuscita: "+e.getMessage(),e);
			return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+" sistema non disponibile";
		}
	}
	public String removeFiltroAbilitazioneServizioPortaDelegata(TipoFiltroAbilitazioneServizi tipo){
		try{
			StatoServiziPdD.removeFiltroAbilitazionePD(tipo);
			return "Operazione effettuata con successo";
		}catch(Throwable e){
			OpenSPCoop2Logger.getLoggerOpenSPCoopCore().error("Operazione removeFiltroAbilitazioneServizioPortaDelegata non riuscita: "+e.getMessage(),e);
			return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+" sistema non disponibile";
		}
	}
	public String removeFiltroDisabilitazioneServizioPortaDelegata(TipoFiltroAbilitazioneServizi tipo){
		try{
			StatoServiziPdD.removeFiltroDisabilitazionePD(tipo);
			return "Operazione effettuata con successo";
		}catch(Throwable e){
			OpenSPCoop2Logger.getLoggerOpenSPCoopCore().error("Operazione removeFiltroDisabilitazioneServizioPortaDelegata non riuscita: "+e.getMessage(),e);
			return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+" sistema non disponibile";
		}
	}

	public String visualizzaFiltriAbilitazioniServizioPortaApplicativa(){
		try{
			return StatoServiziPdD.getPAServiceFiltriAbilitazioneAttivi();
		}catch(Throwable e){
			OpenSPCoop2Logger.getLoggerOpenSPCoopCore().error("Operazione visualizzaFiltriAbilitazioniServizioPortaApplicativa non riuscita: "+e.getMessage(),e);
			return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+" sistema non disponibile";
		}
	}
	public String visualizzaFiltriDisabilitazioniServizioPortaApplicativa(){
		try{
			return StatoServiziPdD.getPAServiceFiltriDisabilitazioneAttivi();
		}catch(Throwable e){
			OpenSPCoop2Logger.getLoggerOpenSPCoopCore().error("Operazione visualizzaFiltriDisabilitazioniServizioPortaApplicativa non riuscita: "+e.getMessage(),e);
			return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+" sistema non disponibile";
		}
	}
	public String addFiltroAbilitazioneServizioPortaApplicativa(TipoFiltroAbilitazioneServizi tipo){
		try{
			StatoServiziPdD.addFiltroAbilitazionePA(tipo);
			return "Operazione effettuata con successo";
		}catch(Throwable e){
			OpenSPCoop2Logger.getLoggerOpenSPCoopCore().error("Operazione addFiltroAbilitazioneServizioPortaApplicativa non riuscita: "+e.getMessage(),e);
			return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+" sistema non disponibile";
		}
	}
	public String addFiltroDisabilitazioneServizioPortaApplicativa(TipoFiltroAbilitazioneServizi tipo){
		try{
			StatoServiziPdD.addFiltroDisabilitazionePA(tipo);
			return "Operazione effettuata con successo";
		}catch(Throwable e){
			OpenSPCoop2Logger.getLoggerOpenSPCoopCore().error("Operazione addFiltroDisabilitazioneServizioPortaApplicativa non riuscita: "+e.getMessage(),e);
			return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+" sistema non disponibile";
		}
	}
	public String removeFiltroAbilitazioneServizioPortaApplicativa(TipoFiltroAbilitazioneServizi tipo){
		try{
			StatoServiziPdD.removeFiltroAbilitazionePA(tipo);
			return "Operazione effettuata con successo";
		}catch(Throwable e){
			OpenSPCoop2Logger.getLoggerOpenSPCoopCore().error("Operazione removeFiltroAbilitazioneServizioPortaApplicativa non riuscita: "+e.getMessage(),e);
			return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+" sistema non disponibile";
		}
	}
	public String removeFiltroDisabilitazioneServizioPortaApplicativa(TipoFiltroAbilitazioneServizi tipo){
		try{
			StatoServiziPdD.removeFiltroDisabilitazionePA(tipo);
			return "Operazione effettuata con successo";
		}catch(Throwable e){
			OpenSPCoop2Logger.getLoggerOpenSPCoopCore().error("Operazione removeFiltroDisabilitazioneServizioPortaApplicativa non riuscita: "+e.getMessage(),e);
			return JMXUtils.MSG_OPERAZIONE_NON_EFFETTUATA+" sistema non disponibile";
		}
	}
}