JBoss - chapitre JMX

antislashn.org JBoss - Supervision avec JMX 2 / 125
JMX
● JMX : Java Management eXtension
● Standard pour la gestion et la supervision des
ressources
● inclus de Java SE depuis la version 5
● supervision des ressources matérielles et logicielles
● Standard utilisé massivement dans le monde des
serveurs Java EE
● JBoss est composé d'un serveur JMX dans lequel
viennent s'agréger les différents services

JMX
● Le standard impose de respecter
● une architecture
● une configuration de classes
– avec un système de nommage
– le contrôle est effectué par des modules applicatifs appelés
MBean (Managed Bean)
● Architecture en trois couches
● niveau clients : permet le contrôle
● niveau agent : serveur
● niveau instrumentation : les MBeans

JMX
source : Oracle

JMX
niveau clients
Services :
●Timers
●Notification
Connecteurs et adaptateurs
Serveur de MBean
niveau agent JMX
niveau instrumentation MBean
MBean
MBean
Client JMX

Niveau instrumentation
● Une ressource administrable doit tourner dans
une JVM
● application, service, périphérique
● L'instrumentation de la ressource est effectuée par
les MBeans
● l'écriture d'un MBean doit suivre un modèle de
conception
● une ressource instrumentée par un MBean est
administrable par l'agent JMX

Niveau instrumentation
● Plusieurs types de MBeans
● Standard MBean
– les fonctionnalités sont exposées statiquement par interface
● MXBean
– Standard MBean possédant des contraintes sur les types
● Dynamic MBean
– les fonctionnalités sont exposée dynamiquement
● Model MBean
– MBean générique et configurable
● Open MBean
– Dynamic MBean possédant des contraintes sur les types

Niveau agent
Serveur de
MBeans
MBean
Registry
MBean
meta data
Client
MBean
MBean

Niveau agent
● L'agent JMX (ou serveur JMX) est composé de
● du serveur de MBean
– classe MBeanServer
● de services
– service de notifications : classe Notification
– service de timer : classe Timer
● des connecteurs et adaptateurs de protocoles pour
dialoguer avec la couche client
– connecteur : permet à un client Java de se connecter au serveur –
utilise RMI
– adaptateurs de protocoles : permet au client d'utiliser d'autres
protocoles que RMI

Niveau agent
● Le serveur de MBean joue le rôle de registre
d'objets
● un MBean doit s'enregistrer avec un nom unique
auprès du serveur
– le nom est de type ObjectName
● composé d'un domaine et de propriétés (séparateurs : et ,)
– l'enregistrement peut être effectué par
● l'agent lui-même
● un autre MBean
● une application distante via un service distribué
jboss.deployment:flavor=URL,type=DeploymentScanner

Niveau agent
● Une fois enregistré, un certain nombres
d'opérations sont disponibles sur le MBean
● découverte des opérations disponibles sur le MBean
● lecture et écriture des attributs
● invocation des opérations du MBean
● récupération des notifications émises par le MBean

Niveau agent
● Les services d'agent
● sont généralement eux-mêmes des MBeans
● gèrent les opération de gestion des MBeans
● par défaut :
– service m-let (Management Applet)
● gestion du chargement dynamique des classes
– service moniteur
● gestion des notification
– service de timers
● déclenchements réguliers d'action sur les MBeans
– service de mise en relation des MBeans entre eux

Niveau client
● Client du niveau agent
● Ce niveau fournit une interface de supervision et
administration
● Deux outils sont fournis par le JDK
● jconsole
● jvisualvm
– regroupe plusieurs outils
– la visualisation des MBeans nécessite le chargement d'un
plugin
● Possibilité de créer son propre client

JMX
● Le MBean suit un modèle de conception
● il comporte
– des attributs en lecture / écriture
● spécification des getteur/setteur
– des opérations
– et éventuellement une description

Standard MBean
● Modèle de conception
● spécification de nommage entre l'interface qui expose
les attributs et opération et la classe d'implémentation
● la classe d'implémentation doit posséder un
constructeur par défaut
● les attributs sont spécifiés par les méthodes
getXxx(), setXxx() et isXxx()

Standard MBean
● Codage simple
● une interface
– même nom que la classe d'implémentation suffixé par
MBean
– les getteur/setteur indique si
l'attribut est en lecture et/ou
écriture
● une classe d'implémentation

Standard MBean : couche agent
● Le MBean est identifié dans le serveur par son
nom
● ou ObjectName
● composé de deux parties
– le domaine
– les propriétés
– les deux sont séparés par le caractère :
jboss.deployment:flavor=URL,type=DeploymentScanner

● Étapes principales
● récupération d'un serveur de MBeans
● création d'un ObjectName pour l'enregistrement du
MBean
● enregistrement du MBean auprès du serveur
MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
ObjectName mBeanName = new ObjectName("antislashn.jmx:bean=Hello,type=standard");
HelloMBean mBean = new Hello();
mbs.registerMBean(mBean, mBeanName);

● Pour exécuter le serveur de MBean, il faut activer
l'accès distant à JMX
● -Dcom.sun.management.jmxremote
● d'autres propriétés peuvent être précisées si en mode
remote
● un modèle de fichier de mot de passe est proposé
dans le répertoire lib/management du JRE
java -Dcom.sun.management.jmxremote.port=3333
-Dcom.sun.management.jmxremote.ssl=false
-Dcom.sun.management.jmxremote.authenticate=false
MonAppliJava

Standard MBean : supervision
● Des utilitaires de supervisions sont livrés avec le
JDK
● jconsole
● jvisualvm
– qui intègre les utilitaire jconsole, jstat , jinfo, jmap

Standard MBean : supervision
● Exemple de copie d'écran avec jvisualvm

StandardMBean : codage d'un client
● Pour que le client se connecte au serveur de
MBean, il faut que celui ci soit lancé avec les
arguments suivants
-Dcom.sun.management.jmxremote
-Dcom.sun.management.jmxremote.port=3333

StandardMBean : codage d'un client
● Les étapes de codage
● créer une URL
● récupérer un connecteur
● récupérer une connexion
● récupérer un proxy vers le MBean
JMXServiceURL serviceURL = new JMXServiceURL("service:jmx:rmi:///jndi/rmi://:3333/jmxrmi");
JMXConnector jmxConnector = JMXConnectorFactory.connect(serviceURL);
MBeanServerConnection serverConnection = jmxConnector.getMBeanServerConnection();
ObjectName objectName = new ObjectName("antislashn.jmx:bean=Hello,type=standard");
HelloMBean mBean = JMX.newMBeanProxy(serverConnection, objectName, HelloMBean.class);
System.out.println(">>> "+mBean.getName());
le client connaît la classe du MBean
port passé en argument à la JVM du server

Dynamic MBean
● Implémente l'interface DynamicMBean
● la lecture des attributs et opérations disponibles ne se
fait plus par introspection
– utilisation des méthodes redéfinies
● bien que plus complexe à coder, ce type de bean est
plus puissant
– exposition des attributs et opérations à l'exécution
● pour le Standard MBean l'exposition est effectuée à la compilation
– pas d'import de classes spécifique côté client

Dynamic MBean
● Les méthodes de DynamicMean permettent
● de découvrir les attributs et opérations du MBean
– getMBeanInfo()
● de retrouver la valeur d'un attribut, ou d'une liste d'attributs
– Object getAtribute(String attribute)
– AttributeList getAttributes(String[] attributes)
● mettre à jour la valeur d'un attribut, ou d'une liste d'attributs
– void setAttribute(Attribute attribute)
– AttributeList setAttributes(AttributeList attributes)
● d'invoquer une opération
– Object invoke(String action,Object[] params, Object[] types)

Dynamic MBean
● Méta-classes de description
● MBeanInfo : une instance par Dynamic MBean
– conteneur de méta données
● MBeanAttributeInfo : une instance par attribut
● MBeanParameterInfo : une instance par paramètre
● MBeanConstructorInfo : une instance par
constructeur
– contient un ou plusieurs MBeanParameterInfo
● MBeanOperationInfo : une instance par opération
– contient un ou plusieurs MBeanParameterInfo
● MBeanNotificationInfo : une instance par groupe de
notifications

Dynamic MBean
● MBeanAttributeInfo
● description d'un attribut
– name : nom de l'attribut tel qu'il apparaît dans l'interface de
gestion
– type : classe de l'attribut sous forme d'un String
●
Integer.TYPE.getName() ou Hello.class.getName() par exemple
– description : description de l'attribut
– isReadable : indicateur de lecture
– isWritable : indicateur d'écriture
– isis : indicateur d'attribut de type booléen
● l'accesseur débute alors par is au lieu de get

Dynamic MBean
● MBeanParameterInfo
● description d'un paramètre de constructeur ou
d'opération
– name : nom du paramètre tel qu'il apparaît dans l'interface
de gestion
– type : classe du paramètre sous forme d'un String
– description : description du paramètre

Dynamic MBean
● MBeanConstructorInfo
● description d'un constructeur
– name : nom du constructeur tel qu'il apparaît dans l'interface
de gestion
– signature : tableau de MBeanParameterInfo
correspondant à la signature du constructeur

Dynamic MBean
● MBeanOperationInfo
● description d'une opération
– name : nom de l'opération telle qu'elle apparaît dans
l'interface de gestion
– signature : tableau de MBeanParameterInfo
correspondant à la signature du constructeur
– type : type du retour
– impact : indicateur d'impact sur l'état du bean

Dynamic MBean
● MBeanOperationInfo
● valeurs possibles pour la propriété impact
– INFO : état du MBean inchangé, l'opération retourne une
information
– ACTION : l'état du MBean a changé
– ACTION_INFO : l'état du MBean a changé, et l'opération
retourne une information
– UNKNOW : l'impact de l'opération sur l'état du MBean est
inconnu

Dynamic MBean
● MBeanNotificationInfo
● description d'une notification
– name : nom de la notification telle qu'elle apparaît dans
l'interface de gestion
– notifsType : types des notifications qui sont émises par le
MBean sous forme d'un tableau de String
● un type de notification est du type :
vendor[.application][.component][.eventGroup].event

Dynamic MBean
● MBeanInfo
● description d'un MBean
– className : nom de la classe du MBean (String)
– attributes : tableau des MBeanAttributeInfo
– constructors : tableau des MBeanConstructorInfo
– operations : tableau des MBeanOperationInfo
– notifications : tableau des MBeanNotificationInfo

Dynamic MBean
● Codage du MBean
● l'exemple reprends
du Standard MBean Hello
public interface HelloMBean {
// attributs
String getName();
String getColor();
void setColor(String
color);
// opérations
void sayHello();
double add(double a, double
b);
}
public class Hello implements HelloMBean {
private String name ="Toto MBean";
private String color = "vert";
@Override
public String getName() {
return name;
}
@Override
public String getColor() {
return color;
}
@Override
public void setColor(String color) {
this.color = color;
}
@Override
public void sayHello() {
System.out.println(">>> Standard MBean "+name+" - "+color);
}
@Override
public double add(double a, double b) {
return a+b;
}
}

Dynamic MBean - codage
● Déclaration des attributs
● constructeur de la classe MBeanAttributeInfo :
● code (extrait)
MBeanAttributeInfo[] attributeInfos = new MBeanAttributeInfo[2];
attributeInfos[0] = new MBeanAttributeInfo("Name",String.class.getName(),
"Nom du MBean",false,true,false);
attributeInfos[1] = new MBeanAttributeInfo("Color", String.class.getName(),
"Couleur du MBean", true, true, false);
MBeanAttributeInfo(String name, String type,
String description,
boolean isReadable,
boolean isWritable,
boolean isIs)

● Déclaration des opérations
● constructeur de la classe MBeanOperationInfo :
● code (extrait)
MBeanOperationInfo[] operationInfos = new MBeanOperationInfo[5];
MBeanParameterInfo[] parameterInfos = new MBeanParameterInfo[2];
parameterInfos[0] = new MBeanParameterInfo("a", Double.TYPE.getName(), "Paramètre a");
parameterInfos[1] = new MBeanParameterInfo("a", Double.TYPE.getName(), "Paramètre a");
operationInfos[0] = new MBeanOperationInfo("add", "addition de deux double", parameterInfos,
Double.TYPE.getName(), MBeanOperationInfo.UNKNOWN);
MBeanOperationInfo(String name, Method method)

● Méthode getAttribute(...)
public Object getAttribute(String attributeName)
throws AttributeNotFoundException, MBeanException, ReflectionException {
if(attributeName.equals("Color")){
return this.color;
}
else if(attributeName.equals("Name")){
return this.name;
}
else
throw new AttributeNotFoundException("Can't find "+attributeName);
}

● Méthode getAttributes(...)
● retour de type AttributeList
– étend ArrayList, mais sans généricité sur Attribute
– contient des instances de type Attribute
● encapsule les nom et valeur d'un attribut
public AttributeList getAttributes(String[] attributeNames) {
AttributeList list = new AttributeList();
for(String name : attributeNames){
try {
Object value = this.getAttribute(name);
list.add(new Attribute(name, value));
} catch (AttributeNotFoundException | MBeanException | ReflectionException e) {
e.printStackTrace();
}
}
return list;
}

● Méthode setAttribute(...)
public void setAttribute(Attribute attribute)
throws AttributeNotFoundException, InvalidAttributeValueException,
MBeanException, ReflectionException {
String name = attribute.getName();
Object value = attribute.getValue();
if(name.equals("Color") && (value instanceof String)){
this.setColor((String) value);
} else {
new AttributeNotFoundException("Attribut "+name+" inconnu ou en lecture seule");
}
}

● Méthode setAttributes(...)
public AttributeList setAttributes(AttributeList attributes) {
AttributeList list = new AttributeList();
for(int i=0 ; i<attributes.size() ; i++){
try{
Attribute attribute = (Attribute) attributes.get(i);
this.setAttribute(attribute);
String name = attribute.getName();
Object value = attribute.getValue();
list.add(new Attribute(name, value));
} catch(Exception e){
e.printStackTrace();
}
}
return list;
}

● Méthode invoke(...)
● est invoquée pour chaque opération
– pas pour les accesseurs/mutateurs des attributs
● il faut vérifier que le nom de la méthode et la signature
soient adéquats
– sinon il faut lever une ReflectionException
● il faut aussi vérifier le tableau des paramètres
– les types des paramètres correspondent-ils à la signature

● Méthode invoke(...)
public Object invoke(String operationName, Object[] params, String[] signature)
throws MBeanException, ReflectionException {
Object retour = null;
if(operationName.equals("sayHello")){
this.sayHello();
retour = Void.TYPE;
}
else if(operationName.equals("add")){
if(signature[0].equals(Double.TYPE.getName()) &&
signature[1].equals(Double.TYPE.getName())){
if(params[0] instanceof Double && params[1] instanceof Double){
double a = ((Double)params[0]).doubleValue();
double b = ((Double)params[1]).doubleValue();
retour = new Double(a+b);
}
}
} else
new ReflectionException(new NoSuchMethodException("Unknow operation : "+operationName));
return retour;
}

Dynamic MBean
● Plus complexe à coder, mais...
● les opérations et attributs peuvent évoluer durant le
cycle de vie du bean
– les méthodes de description du MBean sont appelées tout
au long de l'utilisation du MBean
– pour un Standard MBean, l'exposition des attributs et des
méthodes passe par une interface

Dynamic MBean : codage d'un client
● Étapes de codage
● construction de l'URL
● récupération d'un connecteur
● récupération d'une connexion au serveur JMX
● utilisation de la connexion au serveur pour
– récupérer les méta-données du MBean
– utiliser les attributs
– invoquer les opérations

Dynamic MBean : coadeg d'un client
● Exemple de code
ObjectName objectName = new ObjectName("antislashn.jmx:bean=Hello,type=dynamic");
MBeanInfo beanInfo = serverConnection.getMBeanInfo(objectName);
MBeanAttributeInfo[] attributeInfos = beanInfo.getAttributes();
MBeanOperationInfo[] operationInfos = beanInfo.getOperations();
for(MBeanAttributeInfo att : attributeInfos){
System.out.println(">>> Attribut : "+att.getName()+" == "+
serverConnection.getAttribute(objectName, att.getName()));
}
for(MBeanOperationInfo op : operationInfos){
System.out.println(">>> Opération : "+op.getName());
if(op.getName().equals("sayHello"))
System.out.println("=> sayHello() returns "+
serverConnection.invoke(objectName, op.getName(),
new Object[0], new String[0]));
}
le client ne connaît pas la classe du MBean

Model MBean
● Type de MBean dynamique
● n'implémente aucune interface
● Le MBean n'a pas besoin de détenir une référence
vers la ressource à gérer
● Utilise la classe RequiredModelBean pour
associer une description de MBean à la ressource
à superviser

Model MBean
● Pour résoudre l'interface du Model MBean, on
utilise une classe de méta-données
● Descriptor
– interface implémentée par DescriptionSupport
– collection de paires nom/valeur (String/Object)
● une paire représente un attribut, un constructeur, une opération ou
une notification
● il y a un descripteur par type de champ
● le descripteur décrit complètement le champ par la paire nom/valeur
– les noms utilisés sont liés à la spécification

Model MBean
● Interface Descriptor
● permet la résolution des champs
– les noms de champs sont spécifiés par JMX
– des noms personnalisés peuevent être ajoutés
● méthodes
– Object getFieldValue(String fieldName)
– void setField(String fieldName, Object fieldValue)
– String[] getFields()
– String[] getFieldNames()
– void removeField(String fieldName)
– void setFields(String[] fieldNames,
Object[] fieldValues)

Model MBean
● Champs utilisés par la spécification
● name (obligatoire) : nom utilisé par le champ
● descriptorType (obligatoire) : description du type de
champ, valeurs possibles
– MBean, attribute, operation, notification
● displayName : nom utilisé pour l'affichage dans le client
● getMethod : nom du getteur si le type est un attribut
– doit être déclaré dans les opérations
● setMethod : nom du setteur si le type est un attribut
– doit être déclaré dans les opérations

Model MBean
● currencyTimeLimit : utilisé sur les attributs
(getteur) et retour d'opérations pour estimer sa validité
– une marque lastUpdateTimeStamp est déposée sur
chaque valeur retournée
– unité : ms
● log : sur les notification, indicateur booléen
● logFile : obligatoire si log est utilisé, contient le
chemin d'un fichier de log

Model MBean
● default : valeur par défaut d'un attribut
– utilise le setteur
● export : indicateur booléen utilisé pour la distribution
du MBean dans un environnement distribué
● role: utilisé sur les opération, sa valeur peut être
– operation, constructor, getter, setter
● persistPeriod : période de persistance en s, si
une persitPolicy a été déclarée avec la valeur
NoMoreOftenThan ou OnTimer

Model MBean
● persistPolicy : stratégie de persistance, valeurs
possibles
– Never, OnTimer, OnUpdate, NoMoreOftenThan
● severity : degrès de sévérité d'une notification
– 0 : indéterminé
– et de 1 (NonRecoverable) à 6 (informative)
● value : utilisé comme cache sur les valeur d'attribut
en conjonction avec le champ currencyTimeLimit

Model MBean
● Codage d'un descripteur
● Le descripteur peut être une chaîne XML
● Peut aussi être un tableau de String, String + Object
Descriptor attrDescriptor = new DescriptorSupport();
attrDescriptor.setField("name", "Name");
attrDescriptor.setField("descriptorType", "attribute");
attrDescriptor.setField("displayName", "Nom du Model MBean");
attrDescriptor.setField("getMethod", "getName");
<descriptor>
<field name="name" value="Name" />
<field name="descriptorType" value="attribute"/>
<field name="displayName" value="Nom du Model MBean"/>
<field name="getMethod" value="getName"/>
</descriptor>
Descriptor attrDescriptor = new DescriptorSupport(descriptorXML) ;

Model MBean
● Description de l'interface du MBean
● comme pour le Dynamic MBean il y a un ensemble de
classes pour les méta-données
– ModelMBeanAttributeInfo : une instance par attribut
– ModelMBeanConstructorInfo : une instance par
constructeur
– ModelMBeanOperationInfo : une instance par opération
– ModelMBeanNotificationInfo : une instance par
groupe de notifications
– ModelMBeanInfoSupport : une instance pour le MBean
● conteneur des méta-données

Model MBean
● Constructeurs des classes méta-données
● sauf pour ModelMBeanInfo
● plusieurs constructeurs
– cf. documentation
– certains ne prennent pas d'instance de Descriptor
● il y a alors création d'une instance de Descriptor par défaut, avec
les champs nécessaires
– l'utilisation d'un Descriptor permet d'ajouter les champs
non prévus par les constructeurs

Model MBean
● Méta-données pour les attributs
attributeInfos = new ModelMBeanAttributeInfo[2];
Descriptor nameDescriptor = new DescriptorSupport();
nameDescriptor.setField("name", "Name");
nameDescriptor.setField("descriptorType", "attribute");
nameDescriptor.setField("displayName", "Nom du ModelMBean Hello");
nameDescriptor.setField("getMethod", "getName");
Descriptor colorDescriptor = new DescriptorSupport();
colorDescriptor.setField("name", "Color");
colorDescriptor.setField("descriptorType", "attribute");
colorDescriptor.setField("displayName", "Couleur ModelMBean Hello");
colorDescriptor.setField("currencyTimeLimit", -1);
colorDescriptor.setField("getMethod", "getColor");
colorDescriptor.setField("setMethod", "setColor");
attributeInfos[0] = new ModelMBeanAttributeInfo("Name", String.class.getName(),
"Nom du Model MBean", true, false,false, nameDescriptor);
attributeInfos[1] = new ModelMBeanAttributeInfo("Color",String.class.getName(),
"Couleur du Model MBean", true,true,false,colorDescriptor);

Model MBean
● Méta-données pour les opérations
operationInfos = new ModelMBeanOperationInfo[5];
MBeanParameterInfo a = new MBeanParameterInfo("a", Integer.TYPE.getName(),
"Premier paramètre de l'addition");
MBeanParameterInfo b = new MBeanParameterInfo("b", Integer.TYPE.getName(),
"Second paramètre de l'addition");
MBeanParameterInfo color = new MBeanParameterInfo("colorr", String.class.getName(),
"Couleur du bean");
operationInfos[0] = new ModelMBeanOperationInfo("add","Addition entre deux entiers",
new MBeanParameterInfo[]{a,b},
Integer.TYPE.getName(),ModelMBeanOperationInfo.INFO);
operationInfos[1] = new ModelMBeanOperationInfo("sayHello","Juste un Hello, world",
null,
Void.TYPE.getName(),ModelMBeanOperationInfo.INFO);
operationInfos[2] = new ModelMBeanOperationInfo("getName","getName()",
null,
String.class.getName(),ModelMBeanOperationInfo.INFO);
operationInfos[3] = new ModelMBeanOperationInfo("getColor","getColor()",
null,
String.class.getName(),ModelMBeanOperationInfo.INFO);
operationInfos[4] = new ModelMBeanOperationInfo("setColor","setColor()",
new MBeanParameterInfo[]{color},
Void.TYPE.getName(),ModelMBeanOperationInfo.INFO);

Model MBean
● Méta-données pour le Model MBean
● Association avec la ressource
mBeanInfo = new ModelMBeanInfoSupport("ModelMBeanHello", "Exemple de Model MBean",
attributeInfos,
null,
operationInfos,
null);
MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
ObjectName mBeanName = new ObjectName("antislashn.jmx:bean=Hello,type=model");
ModelMBeanHelloFactory factory = new ModelMBeanHelloFactory();
Hello hello = new Hello();
RequiredModelMBean mBean = new RequiredModelMBean(factory.getModelMBeanInfo());
mBean.setManagedResource(hello,"objectReference");

Model MBean
● Exemple de construction des méta-données
● extrait
Descriptor attrDescriptor = new DescriptorSupport();
attrDescriptor.setField("name", "Name");
attrDescriptor.setField("descriptorType", "attribute");
attrDescriptor.setField("displayName", "Nom du Model MBean");
attrDescriptor.setField("getMethod", "getName");
attributeInfos[0] = new ModelMBeanAttributeInfo("Name", String.class.getName(),
"Nom du Model MBean",
true, false,false, attrDescriptor);
attributeInfos[1] = new ModelMBeanAttributeInfo("Color",String.class.getName(),
"Couleur du Model MBean",
true,true,false);
mBeanInfo = new ModelMBeanInfoSupport("ModelMBeanHello", "Exemple de Model MBean",
attributeInfos, null, operationInfos, null);
ModelMBeanAttributeInfo(String name, String type, String description,
boolean isReadable, boolean isWritable, boolean
Descriptor descriptor)

Model MBean
● Récupération du Descriptor
● auprès des classes de méta-données
● méthode Descriptor getDescriptor()
● il est ainsi possible de gérer le descripteur
– lister les champs
– ajouter des champs
– ...

Model MBean
● Mise en relation de la ressource à gérer avec la
description du MBean
ObjectName mBeanName = new ObjectName("antislashn.jmx:bean=Hello,type=model");
ModelMBeanHelloFactory factory = new ModelMBeanHelloFactory();
Hello hello = new Hello();
RequiredModelMBean mBean = new RequiredModelMBean(factory.getModelMBeanInfo());
mBean.setManagedResource(hello,"ObjectReference");
classe utilitaire construisant les descripteur
association du descripteur et de la ressource

Model MBean
● Association entre la ressource et le descripteur de
MBean
● type de référence
– ObjectReference : seul supporté par défaut dans le JDK
– Handle
– IOR
– EJBHandle
– RMIReference

Model MBean
● Résumé des étapes d'instrumentation d'une
ressource
● instancier la ressource à gérer
● instancier la classe RequiredModelBean
● créer les classes de méta-données nécessaires
● créer la méta-donnée pour la ressource
– ModelMBeanInfo
● ajouter à l'instance de RequiredModelBean la méta-
donnée de type ModelMBeanInfo
● associer la ressource

MBean - comparaison
type
de
MBean
connaissance
du MBean par
le client
complexité
de
codage
utilisation
des
Open Type
Standard MBean oui simple non
Dynamic MBean non tout doit être codé non
Model MBean non implémentation par défaut fournie non
MXBean oui simple oui
Open MBean non complexe oui
● Les Model MBean et Dynamic MBean sont mis en
relation avec la ressource à surveiller
● ils ne possèdent pas de référence vers cette ressource
● ils n'encapsulent pas cette ressource

Notification d'événements
● Le changement d'état d'une ressource peut-être notifiée
● par programmation
● par utilisation du service de monitoring
● La notification est une information envoyée par un
émetteur vers un listener via l'infrastructure JMX
● contient au minimum
– le type de la notification – String
● du type vendor[.application][.component][.eventGroup].event
– une référence vers l'émetteur
– un numéro de séquence qui identifie l'occurrence de la notification

● Classes et interfaces principales
● classe Notification : représente une notification
– envoyée par un émetteur (broadcaster) vers un récepteur
(listener)
● interface NotificationFilter : permet au listener de
ne recevoir qu'une partie des notifications
– implémentée par NotificationFilterSupport
● interface NotificationBroadcaster : implémentée par tous
les émetteurs
– implémentée par NotificationBroadcastSupport
● interface NotificationListener : implémentée par
les récepteurs de notification

● Un émetteur :
● implémente l'interface NotificationBroadcaster
– ou étend NotificationBroadcasterSupport
● fournir à l'infrastructure JMX les notifications susceptibles
d'être émises
– méthode MBeanNotificationInfo[] getNotificationInfo()
● Un récepteur étends l'interface
NotificationListener
● le listener peut recevoir un sous-ensemble des
notifications en fournissant une filtre
– le filtre implémente NotificationFilter

Notification d'événements - exemple
● Une classe Compteur fait évoluer régulièrement
une valeur interne
● une notification sera émise à chaque changement de
cette valeur
● La classe Compteur
● implémente CompteurMBean
● étend NotificationBroadcastSupport
– redéfinition de la méthode getNotificationInfo()
● maintient un numéro de séquence de notification
● envoie une notification sur sa méthode setValue(...)

● Redéfinition de la méthode getNotificationInfo()
...
@Override
public MBeanNotificationInfo[] getNotificationInfo(){
MBeanNotificationInfo[] infos = new MBeanNotificationInfo[1];
String[] types = new String[]{"antislashn.compteur.value"};
String name = AttributeChangeNotification.class.getName();
String description = "Un attribut de Compteur a changé";
MBeanNotificationInfo info = new MBeanNotificationInfo(types, name, description);
infos[0] = info;
return infos;
}
...

● Envoi de la notification
● la notification comporte au moins
– le type de notification – String
– une référence vers l'émetteur de la notification
– le numéro de séquence
● plusieurs constructeurs permettent d'ajouter
– un horodatage
– un message
– une référence vers un Object
● permet le passage d’informations supplémentaires entre l'émetteur et
le récepteur – méthode setUserData(Object userData)

● Envoi de la notification
● Nota : la classe AttributeChangeNotification
aurait pu être utilisée
● permet d'ajouter des informations sur la valeur de
l'attribut
– ancienne valeur et nouvelle valeur
Notification notification = new Notification("antislashn.compteur.value",
this, sequenceNumber++);
sendNotification(notification);

● Pour suivre les notification dans jconsole ou
jvisualvm, il faut d'abord souscrire

● Et de voir les changements

● L'implémentation de NotificationListener
permet de suivre les notifications avec son propre
client
● le client doit auparavant se connecter sur notre
serveur JMX
– via un adaptateur RMI
● l'url comporte le port d'écoute du serveur
– argument com.sun.management.jmxremote.port

● Le client doit ensuite retrouver le MBean pour
s'enregistrer en tant que listener
ObjectName objectName = new ObjectName("antislashn.jmx:type=Compteur,subtype=Notification");
CompteurMBean compteurMBean = JMX.newMBeanProxy(serverConnection, objectName,
CompteurMBean.class, true);
serverConnection.addNotificationListener(objectName, new CompteurListener(), null, null);
le MBean peut
envoyer
des notifications
pas de
filtre
pas d'objet
handback

● Le listener n'a qu'une méthode à implémenter
● handleNotification()
– premier paramètre : la notification
– seconde paramètre : l'objet handback
class CompteurListener implements NotificationListener{
@Override
public void handleNotification(Notification notification, Object handback) {
System.out.println(">>> Notification "+notification.getSource());
}
}
renvoie
l'OjectName du
MBeanc

● Utilisation d'une donnée utilisateur
● les ancienne et nouvelle valeurs du compteur sont
encapsulées dans une classe
public class UserData implements Serializable{
private int oldValue;
private int newValue;
public UserData(int oldValue, int newValue) {
this.oldValue = oldValue;
this.newValue = newValue;
}
public int getOldValue() {
return oldValue;
}
public int getNewValue() {
return newValue;
}
}

● Utilisation d'une donnée utilisateur
● mise en place de la donnée utilisateur côté MBean
●
●
●
● récupération dans le listener (côté client)
private void sendNotification() {
Notification notification = new Notification("antislashn.compteur.value",
this, sequenceNumber++);
UserData userData = new UserData(value-1, value);
notification.setUserData(userData);
sendNotification(notification);
}
@Override
System.out.println(">>> Notification "+notification.getSource());
if(notification.getUserData()!=null){
UserData userData = (UserData) notification.getUserData();
System.out.println("t oldValue == "+userData.getOldValue()+
" - newValue == "+userData.getNewValue());
}
}
}

● Utilisation de l'objet de retour
● objet créé par le listener
● passé à l'émetteur de notification via la méthode
addNotificationListener()
● retourné à la méthode handleNotification() du
listener
● Permet de créer des contextes propres aux
listeners

● Mise en place du handback
● lors de l'ajout du listener
● l'objet peut-être évidemment de tout type
● Récupération du handback
String typeLog = "email";
serverConnection.addNotificationListener(objectName, new CompteurListener(), null, typeLog);
@Override
String typeLog = (String) handback;
if(typeLog.equals("console")){
System.out.println(">>> Notification sur la console "+notification.getSource());
}else if(typeLog.equals("email")){
sendEmail();
}
}
}

● Filtrer les notifications
● par implémentation de NotificationFilter
– encapsule la liste des types de notifications permis
– définit la méthode isNotificationEnabled() qui renvoie un
booléen indiquant la prise en charge ou non de l'envoi de la
notification au listener
● par utilisation de la classe
NotificationFilterSupport
– la méthode enableType() permet d'enregistrer les types de
notifications permis
● l'enregistrement du filtre est effectué lors de l'ajout du
listener
– méthode addNotificationListener(...)

● par implémentation de NotificationFilter
class CompteurNotificationFilter implements NotificationFilter {
String[] types = { "antislashn.counter.down" };
@Override
public boolean isNotificationEnabled(Notification notification) {
for (String type : types) {
if (type.equals(notification.getType()))
return true;
}
return false;
}
}

● par utilisation de NotificationFilterSupport
NotificationFilterSupport filter = new NotificationFilterSupport();
filter.enableType("antislashn.counter.down");
serverConnection.addNotificationListener(objectName, new CompteurListener(), filter, null);

MXBean
● Le MXBean est un Standard MBean avec des
restrictions sur les types
● pas d'utilisation de types personnalisés
● utilisation de OpenType<T> et de ses types dérivés
● le client de MXBean n'a pas besoin de connaître la
classe métier utilisée
– le codage de la partie cliente est moins directe
● mais plus générique
● cf. http://docs.oracle.com/javase/7/docs/api/javax/management/MXBean.html

MXBean
● Exemple de Standard MBean exposant une
classe métier Contact
● Utilisation par le client
public interface ContactServiceMBean {
void addContact(Contact contact);
List<Contact> getAllContacts();
Contact getContact(int id);
}
...
ObjectName objectName = new ObjectName("antislashn.jmx:type=ContactService");
ContactServiceMBean contactService = JMX.newMBeanProxy(serverConnection,
objectName, ContactServiceMBean.class);
Contact c1 = contactService.getContact(1);
...
La classe Contact est
importée

MXBean
● Pour transformer le Standard MBean en XMBean,
il faut implémenter une interface postfixée par
MXBean au lieu de MBean
public interface ContactServiceMBean {
}
public interface ContactServiceMXBean {
}

MXBean
● Le client ne récupère plus une classe métier mais
un CompositeType
● on interroge alors le CompositeType
– par le nom des propriétés du type métier
● les collections sont transformées en tableaux
ObjectName objectName = new ObjectName("antislashn.jmx:type=MXContactService");
CompositeData[] liste = (CompositeData[]) serverConnection.getAttribute(objectName, "AllContacts");
for(CompositeData data : liste){
String name = (String) data.get("name");
int age = (int) data.get("age");
System.out.println("Contact : "+name+ " - "+age);
}
interrogation de l'attribut AllContacts
du XMBean
récupération des propriétés de l'objet
métier par leur nom

Services de monitoring
● Permet d'observer les valeurs des attributs d'un
MBean
● le MBean est l'objet observé
● le moniteur observe le MBean à intervalle régulier
– en ms (granularity period)
– une notification est envoyée lorsqu'une condition est
satisfaite
● la condition varie en fonction du type de moniteur
– le moniteur peut calculer une valeur par différence (derived
gauge)
● pour les attributs numériques
● non activé par défaut
– cf. méthode setDifferenceMode(boolean value)

● Trois moniteurs de surveillance sont fournis par défaut dans
l'implémentation JMX

● Surveillance de comptage
● CounterMonitor
● observe l'augmentation d'un attribut entier d'un MBean
– byte, short, int, long et classes associées
– envoie une notification si la valeur de l'attribut observé
dépasse une certaine valeur (threshold)
● possibilité de relancer la notification
– setOffset(Number value)
– mode de calcul par différence
● if (counter[t] - counter[t-GP]) is positive then V[t] = counter[t] - counter[t-GP]
● if (counter[t] - counter[t-GP]) is negative then V[t] = counter[t] - counter[t-GP] + MODULUS
– GP => garnularity period

● Surveillance d'évolution
● GaugeMonitor
● observe un changement arbitraire d'un attribut
numérique d'un MBean
– int, long, float, double et classes associées
– envoie une notification si la valeur dérivée
● passe au-dessus d'une limite haute (high threshold)
● passe en-dessous d'une limite basse (low threshold)

● Surveillance de chaîne de caractères
● StringMonitor
● observe un changement sur attribut de type String d'un
MBean
● envoie une notification lorsque la valeur dérivée
– est égale à une chaîne de caractère précise
– diffère d'une chaîne de caractère précise

CounterMonitor - exemple
● Un MBean compteur change sa propre valeur sur un
thread
● attribut Value
● Un CounterMonitor surveille se MBean
● Mise en place de la surveillance
MBeanServer server = ManagementFactory.getPlatformMBeanServer();
ObjectName compteurObjectName = new ObjectName("antislashn.jmx:type=Compteur");
CompteurMBean compteurMBean = new Compteur();
server.registerMBean(compteurMBean, compteurObjectName);
ObjectName monitorObjectName = new ObjectName("antislashn.jmx:type=Monitor");
CounterMonitor monitor = new CounterMonitor();
monitor.addObservedObject(compteurObjectName);
monitor.setObservedAttribute("Value");
…
server.registerMBean(monitor, monitorObjectName);
enregistrement du MBean Compteur
enregistrement du CounterMonitor
objet et attribut observé

● Signal généré par le CompteurMBean
● Stratégie mise en place
● période de surveillance : toute les secondes
● une notification est lancée si l'attribut est supérieur à 7
monitor.setGranularityPeriod(1000);
monitor.setInitThreshold(7);
monitor.setNotify(true);
0
100
10 s

● une notification est lancée si la valeur de l'attribut
surveillé est supérieur à 7
0
Integer.MAX_VALUE
incrément de 1 toutes les 100 ms

● une notification est lancée si la valeur de l'attribut
surveillé est supérieur à 7
0
Integer.MAX_VALUE

● une notification est lancée si l'attribut est supérieur à 7
● l'offset ajouté au threshold a chaque fois que la valeur
sous surveillance est supérieure au threshold
– permet de lancer plusieurs
notifications
monitor.setOffset(5);
0
Integer.MAX_VALUE

GaugeMonitor - exemple
0
100
10 s
GaugeMonitor monitor = new GaugeMonitor();
monitor.addObservedObject(compteurObjectName);
monitor.setObservedAttribute("Value");
monitor.setThresholds(7, 3);
monitor.setNotifyHigh(true);
monitor.setNotifyLow(true);

Timer Service
● Émetteur de notifications programmable
● intervalle fixe
● date donnée
● etc.
● Structure du service
● le service émet des TimerNotification

Timer Service
● Classe Timer
● utilise un thread secondaire
● méthode addNotification(...)
– ajoute une notification à la file des notifications à envoyer
– plusieurs signatures
● envoi d'une notification
● envoi période de notification
● envoi d'un nombre prédéfini de notification

Timer Service
● Utilisation du timer
● création d'une instance de Timer
● ajout d'une notification
● ajout d'un listener
● démarrage du timer
Timer mBean = new Timer();
Date date = new Date(new Date().getTime()+Timer.ONE_SECOND*2);
mBean.addNotification("antislashn.timer.test", "test 1", null, date);
mBean.addNotification("antislashn.timer.test", "test 2", null, date,1000,10);
mBean.addNotificationListener(new TimerNotificationListener(), null, null);
mBean.start();
une notification sera
envoyée à la date
programmée
10 notifications seront envoyées, toutes
les secondes, à partir de la date
programmée

Monitoring de la JVM
● Plusieurs fonctionnalités ont été ajoutées depuis
le JDK 1.5
● la JVM est instrumentée avec des MBean
● existence d'une API de monitoring
– permet d'obtenir des informations sur l'état de la JVM durant
son exécution
● mémoire, threads, garbage collector, …
– utilisable sous forme de MBean de type MXBean
● chaque MBean est identifié par son ObjectName
● ils implémentent l'interface PlatformManagedObject
● des méthodes la classe ManagementFactory permettent de
récupérer directement les MXBeans

● Exemple sur OperatingSystemMXBean
OperatingSystemMXBean mxBean = ManagementFactory.getOperatingSystemMXBean();
System.out.println("Architecture : "+mxBean.getArch());
System.out.println("Nb de processeurs : "+mxBean.getAvailableProcessors());
System.out.println("Système d'exploitation : "+mxBean.getName()+" "+mxBean.getVersion());
System.out.println("Charge du système : "+mxBean.getSystemLoadAverage());
Architecture : x86
Nb de processeurs : 8
Systeème d'exploitation : Windows 7 6.1
Charge du système : -1.0
la charge n'a pas pu être
calculée

● Exemple sur RuntimeMXBean
RuntimeMXBean rBean = ManagementFactory.getRuntimeMXBean();
System.out.printf("Boot classpath : %sn", rBean.getBootClassPath());
System.out.printf("classpath : %sn", rBean.getClassPath());
System.out.println("Input argument :");
List<String> arguments = rBean.getInputArguments();
for (String arg : arguments) {
System.out.println(" " + arg);
}
System.out.printf("Library path : %sn", rBean.getLibraryPath());
System.out.printf("Management spec version : %sn",
rBean.getManagementSpecVersion());
System.out.printf("Name : %sn", rBean.getName());
System.out.printf("Spec name : %sn", rBean.getSpecName());
System.out.printf("Vendor : %sn", rBean.getSpecVendor());
System.out.printf("Spec version : %sn", rBean.getSpecVersion());
System.out.printf("StartTime : %d msn", rBean.getStartTime());

Service JBoss – jusqu'à version 6
● Les services sont des archives SAR déployés
dans le répertoire de déploiement
● l'archive contient un fichier de description du service
– META-INF/jboss-service.xml
● Le service créé doit utiliser les classes JBoss
● interface org.jboss.system.ServiceMBean
● classe org.jboss.system.ServiceMBeanSupport
– fournit des méthodes de gestion du cycle de vie du service

● Diagramme de classe de l'exemple HelloService

● Code de l'exemple (extraits)
public interface HelloServiceMBean extends ServiceMBean{
void setMessage(String message);
String getMessage();
void sayHello();
}
public class HelloService extends ServiceMBeanSupport implements HelloServiceMBean {
private String message;
@Override
public void setMessage(String message) {
this.message = message;
}
@Override
public String getMessage() {
return message;
}
...
}

● Contenu du fichier de déploiement
● META-INF/jboss-service.xml
– cf. la DTD jboss-service_x_y.dtd (version x, release y)
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE server>
<server>
<mbean code="org.antislashn.jmx.HelloService"
name="antislashn.service:service=HelloService">
<attribute name="Message">Bonjour tout le monde</attribute>
</mbean>
</server>
classe d'implémentation
ObjectName du service
initialisation de l'attribut Message

● Attributs les plus courants pour <mbean> :
● <code> (obligatoire) : classe d'implémentation
● <name> (obligatoire) : JMX ObjectName du MBean
● <interface> : nom qualifié de l'interface, par défaut
le nom de cette interface suit la spécification MBean

● Éléments fils les plus courants pour <mbean> :
● <constructor (args*)> : spécifie un constructeur,
si le constructeur par défaut n'est pas utilisé
– <arg> : argument du constructeur, possède les attributs
type et value
● <attribute> : permet l'initialisation d'un attribut du
MBean
● <depends> : spécifie une dépendance vers un autre
MBean
● Cf. la DTD pour une documentation exhaustive

● La console JMX de JBoss permet de vérifier la
prise en compte du déploiement du service

Service JBoss – version 7
● Deux stratégies de mise en place d'un service
● service JMX MBean
– plus simple qu'avec les versions précédentes
– pas besoin d'étendre les classes et interfaces JBoss
● les méthode start() et stop() seront automatiquement appelées
– le fichier META-INF/jboss-service.xml référencie un schéma
XML au lieu d'une DTD
● service EJB
– ce n'est pas un service JMX
– avec les annotations @Singleton et @Startup

● Exemple de service JMX
public interface HelloServiceMBean {
void setMessage(String message);
String getMessage();
void sayHello();
}
public class HelloService implements HelloServiceMBean {
private String message;
@Override
public void setMessage(String message) {this.message = message;}
@Override
public String getMessage() {return message;}
@Override
public void sayHello() {System.out.println(">>> HelloService : "+message);}
public void start() throws Exception {System.out.println(">>> CYCLE DE VIE HelloService start");}
public void stop() {System.out.println(">>> CYCLE DE VIE HelloService stop");}
}

● Exemple de fichier de déploiement
● META-INF/jboss-service.xml
● cf. le schéma pour plus de détails
<?xml version="1.0" encoding="UTF-8"?>
<server xmlns="urn:jboss:service:7.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="urn:jboss:service:7.0 jboss-service_7_0.xsd">
<mbean code="org.antislashn.jmx.HelloService"
name="antislashn.service:service=Hello,type=test">
<attribute name="Message">Hello, world</attribute>
</mbean>
</server>

● Le service est disponible dans la console JBoss,
ainsi que par jconsole ou jvisualvm

Console en mode distant
● jconsole ou jvisualvm peuvent se connecter en
mode distant
● côté serveur JMX il faut au moins lancer l'application
Java avec l'indication du port utilisé
● lancer alors la console en mode "Remote Process"
-Dcom.sun.management.jmxremote.port=3333

● Activation du fichier des mots de passe
● deux fichiers sont nécessaires
– fichier des droits d'accès
● par défaut : JRE_HOME/lib/management/jmxremote.acces
● définit les droits d'accès
– fichier des mots de passe
● par défaut : JRE_HOME/lib/management/jmxremote.password
● définit les mots de passe
● le fichier modèle doit être renommé
● les fichiers doivent être en lecture seule
– attention à l'héritage des droits sous Windows

● Activation du fichier des mots de passe
● si les fichiers utilisé ne sont pas sous
JRE_HOME/lib/management il faut ajouter les
arguments suivant à la JVM
– ici les fichiers sont recherché dans le répertoire du projet
● En production il est préférable
● d'activer SSL
● d'utiliser JAAS pour l'authentification
-Dcom.sun.management.jmxremote.access.file=jmxremote.access
-Dcom.sun.management.jmxremote.password.file=jmxremote.password

Client personnalisé en mode distant
● Si le mode distant est sécurisé, il faut passer le
rôle et le mot de passe au moment de la
connexion
● extrait de code
String[] credential = {"controlRole","titi"};
Map<String,String[]> env = new HashMap<String,String[]>();
env.put(JMXConnector.CREDENTIALS, credential);
JMXConnector jmxConnector = JMXConnectorFactory.connect(serviceURL,env);
ObjectName objectName = new ObjectName("antislashn.jmx:bean=Hello,type=standard");
HelloMBean mBean = JMX.newMBeanProxy(serverConnection, objectName, HelloMBean.class);

Console en mode distant – problèmes
potentiels
● Gestion des droits sous Windows
● au lancement du serveur JMX l'erreur suivante apparaît
● il faut modifier les droits (click droit sur le fichier)
Erreur: L'accès en lecture au fichier de mots de passe doit être limité: jmxremote.password
cf page
suivante

potentiels
● Gestion des droits sous Windows (suite)
décocher
cf page
suivante

potentiels
● Gestion des droits sous Windows (suite)
OK OK
supprimer tous les utilisateurs
sauf l'administrateur

Pour aller plus loin
● MXBean
● MBean permetant l'utilisation des types utilisateurs au
travers des OpenType<T>
● OpenMBean
– dynamique MBean utilisant les OpenType<T>
● M-Let service
● service de chargement dynamique des MBeans
● RelationService
● service de mise en relation des MBeans entre eux

Pour aller plus loin
● Les OpenType<T>
● décrit un type de donnée utilisé par les OpenMBeans
et les MXBeans
– SimpleType : type simple
● wrapper de type primitif, String, Date, ObjectName
– CompositeType : type composé d'autres OpenType
– TabularType : données tabulaires
– ArrayType : données sous forme de tableau

Références
● Livres
● Java Management Extension
– auteur : J. Steven Perry
– éditeur : O'Reilly
● JMX – Managing J2EE with Java Management Extension
– auteurs : Juha Lindfors, Marc Fleury, The JBoss Group
– éditeur : SAMS
● Web
● http://docs.oracle.com/javase/7/docs/technotes/guides/jmx/JMX_1_4_specification.pdf
● http://www.jmdoudoux.fr/java/dej/chap-jmx.htm#jmx-12

copyleft
Support de formation créer par
Franck SIMON
http://www.franck-simon.com

copyleft
Cette œuvre est mise à disposition sous licence
Attribution
Pas d'Utilisation Commerciale
Partage dans les Mêmes Conditions 3.0 France.
Pour voir une copie de cette licence, visitez
http://creativecommons.org/licenses/by-nc-sa/3.0/fr/
ou écrivez à
Creative Commons, 444 Castro Street, Suite 900,
Mountain View, California, 94041, USA.

JBoss - chapitre JMX

Contenu connexe

Tendances

En vedette

Similaire à JBoss - chapitre JMX

Plus de Franck SIMON

JBoss - chapitre JMX