MiddleWAR & Co

GrandMA 2 DIY - Fabriquer son clavier programmable

Corentin Azelart — Sat, 28 Jan 2012 11:58:00 +0000

A la demande générale sur le groupe MA-Lighting je vais expliquer rapidement comment faire son propre clavier programmable (avec les ressources : étiquettes, fichiers de mapping clavier, etc...).

Au niveau des pré-requis vous avez besoin :

Une version >= 2.5.3.6 de onPC
Un clavier programmable : le JR Prog 78T de JR Commercique au prix de 109.00€ (version USB)
Un fichier de mapping pour onPC : GrandMA 2 Shortcuts XML
Un fichier de mapping pour le JR Prog 78T : gma.dat
Des étiquettes : https://docs.google.com/spreadsheet/ccc?key=0AlTa_pTDMWl2dHNEaG90WmI3QmFXc081RUUybjZxT0E

Ensuite étape par étapes :

Installer onPC et le clavier programmable (voir les liens ci-dessus pour retrouver les drivers et les logiciels)
Configurer les raccourcis sur onPC : Setup > Console > Edit Keyboard Shortcuts > Import, sélectionnez le fichier grandma_shortcutmapping.xml

Même opération avec le logiciel du JR Prog 78T : Ouvrir > Sélectionnez le fichier gma.dat puis cliquez sur l'icone avec la flèche verte pour charger la configuration physiquement sur le clavier.
Pour finir n'hésitez pas à décorer un peu : https://docs.google.com/spreadsheet/ccc?key=0AlTa_pTDMWl2dHNEaG90WmI3QmFXc081RUUybjZxT0E

VisualVM - Configurer avec Tomcat démarré en service Windows

Corentin Azelart — Tue, 17 Jan 2012 13:33:00 +0000

Un petit tutoriel pour expliquer rapidement la mise en oeuvre de VisualVM avec un serveur Tomcat (ici version 7) en tant que service sous Windows Serveur.

Avant de commencer vous devez avoir Tomcat installé en service, ce tuto ne traite pas ce sujet. Le site de Tomcat présente particulièrement bien cette partie dans la documentation.

Ouvrir l'utilitaire fournit avec l'installation de Tomcat (tomcat7w) présent dans le répertoire /bin. Cet utilitaire permet de gérer le service Windows (si il est installé).
Allez dans l'onglet : JAVA et ajoutez les paramètres suivants dans le bloc 'Java Options' :

Dcom.sun.management.jmxremote Dcom.sun.management.jmxremote.port=5555 Dcom.sun.management.jmxremote.ssl=false Dcom.sun.management.jmxremote.authenticate=false

Attention : ne pas appliquer sur un serveur exposé directement sur Internet, pensez à sécuriser dans le cas contraire

Lancez Visual VM sur votre poste puis File > Add JMX Connection...
Entrez l'adresse et le port dans le champ Connection : exemple 127.0.0.1:5555 (n'oubliez pas il s'agit du port indiqué dans le paramètre : -Dcom.sun.management.jmxremote.port (ici 5555).

Installer Tomcat 7 en service

Corentin Azelart — Thu, 05 Jan 2012 14:48:00 +0000

Ce billet n'est pas un tuto mais plus un guide rapide pour démarrer Apache Tomcat 7 en service sous Windows Server. Nous utilisons ici Windows Serveur 2008 R2, la procédure est la même pour les versions plus récentes de Windows.

On commence point par point :

Positionner les variables d'environnements pour : CATALINA_HOME, JAVA_HOME et JRE_HOME :

Au niveau du répertoire de votre serveur Tomcat exécutez la commande suivante dans un shell Windows : bin\service.bat" install (vous pouvez personnaliser le nom de votre service avec un descriptif à la fin de la commande)

Si votre serveur est en 64 bits il est impératif d’avoir un JRE 64 bits sinon le service ne va pas se lancera pas même le serveur démarre normalement manuellement. Constaté sur la version 7.0.23

Ouvrez la console des services Windows et cliquez sur Démarrer (vous pouvez éventuellement indiquer le démarrage automatique au lancement du système)

Spring-Ldap : Démarrage rapide avec les annotations

Corentin Azelart — Wed, 14 Dec 2011 19:11:00 +0000

Il arrive que pour des questions d'identification et d'authentification qu'il soit nécessaire de se connecter à un Ldap. Mais il arrive aussi d'avoir le besoin uniquement de récupérer des informations (à la demande) comme un numéro de téléphone, une adresse mail, etc... Ce billet à pour but d'expliquer plus en détails le second point moins souvent illustré, notamment avec une couche d’accès aux données (DAO).

Définition du modèle Comme dans une structure classique nous avons nos Bussiness Objects (Hibernate, JPA,...) mappés avec notre base de données via des annotations. Dans le cadre du Ldap nous pouvons imaginer que nos Bussiness Objects soient des objets au sens Ldap du terme. Un exemple avec un objet Person.java

import javax.naming.Name;
 
import org.springframework.ldap.odm.annotations.Attribute;
import org.springframework.ldap.odm.annotations.Entry;
import org.springframework.ldap.odm.annotations.Id;
 
/**
 * Personne au sens LDAP.
 * @author Corentin Azelart.
 *
 */
@Entry(objectClasses = { "top", "person", "organizationalPerson", "user" })
public final class Person {
	/**
	 * Identifiant.
	 */
	@Id
	private Name cn;
 
	/**
	 * Nom d'affichage.
	 */
	@Attribute( name = "displayName" )
	private String displayName;
 
	/**
	 * Departement.
	 */
	@Attribute( name = "department" )
	private String departement;
 
	/**
	 * Numero de tel.
	 */
	@Attribute( name = "telephoneNumber" )
	private String telephone;
 
	/**
	 * Code postal.
	 */
	@Attribute( name = "postalCode" )
	private String codePostal;
 
	/**
	 * Adresse.
	 */
	@Attribute( name = "streetAddress" )
	private String adresse;
 
	/**
	 * Ville.
	 */
	@Attribute( name = "l" )
	private String ville;
 
        ...getters/setters...

On retrouve donc plusieurs attributs :

@Entry(objectClasses = { "top", "person", "organizationalPerson", "user" }) : il s'agit de la définition de l'objet Ldap
@Id : un identifiant de votre objet Ldap
@Attribute( name = "streetAddress" ) : un attribut de votre objet (le name étant le nom côté Ldap)

Définition de notre OdmManager

L'ODM Manager est un peu la DAO d'un ORM, c'est à travers l'ODM que nous allons écrire nos "requêtes Ldap". La configuration est réalisable intégralement au niveau du fichier de configuration de Spring :

<!-- LDAP -->
<bean id="ldapContextSource" class="org.springframework.ldap.core.support.LdapContextSource">
	<property name="url" value="ldap://ldap.votreEntreprise.com:389" />
	<property name="userDn" value="DC=corp,DC=votreEntreprise,DC=com" />
</bean>
<bean id="odmManager" class="org.springframework.ldap.odm.core.impl.OdmManagerImplFactoryBean">
	<property name="converterManager" ref="converterManager" />
	<property name="contextSource" ref="ldapContextSource" />
	<property name="managedClasses">
		<set>
			<value>fr.azelart.ldapsample.bo.ldap.Person</value>
		</set>
	</property>
</bean>

Dans le fichier de configuration on retrouve deux points importants :

La source (LdapContextSource) qui symbolise la connexion, à adapter en fonction de la configuration du serveur Ldap
L'ODM Manager : qui va permettre la configuration et l'injection de l'ODM dans notre couche service, nous précisons les classes à mapper

Création de notre service

Pour taper dans notre ODM Manager et donc dans notre Ldap, nous allons réaliser un service pour "interfacer" l'ensemble. Un exemple de service simple :

import java.util.ArrayList;
import java.util.List;
 
import javax.naming.directory.SearchControls;
 
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.ldap.core.DistinguishedName;
import org.springframework.ldap.odm.core.OdmManager;
import org.springframework.stereotype.Service;
 
import com.capgemini.psp.bo.ldap.Person;
import com.capgemini.psp.bo.psp.Utilisateur;
import com.capgemini.psp.exceptions.TechnicalException;
import com.capgemini.psp.repository.psp.RepositoryUtilisateur;
import com.capgemini.psp.utils.Constantes;
 
/**
 * Service Ldap.
 * @author Corentin Azelart
 */
@Service
public class ServiceLdap {
 
	@Autowired
	private OdmManager odmManager;
 
	/**
	 * Logger.
	 */
	private static Logger sLogger = Logger.getLogger( ServiceLdap.class );
 
	/**
	 * Permet de remonter une liste de Person en fonction d'un mail.
	 * @param pMail est le mail de l'utilisateur ou des utilisateurs.
	 * @return la Person
	 */
	public List<Person> rechercherPerson( String pMail ) {
		final SearchControls vSearchControls = new SearchControls(SearchControls.SUBTREE_SCOPE, 1, 4000, null, true, false);
		final List <Person> vPersons = odmManager.search( Person.class, new DistinguishedName("OU=Employees,DC=corp,DC=votreEntreprise,DC=com"), "mail="+pMail, vSearchControls );
		return vPersons ;
	}
}

Dans la méthode rechercherPerson on retrouve plusieurs instructions :

SearchControls(SearchControls.SUBTREE_SCOPE, 1, 4000, null, true, false) : symbolise la profondeur de recherche, ici le 4000 est le temps max de recherche, après ce délai nous renvoyons les utilisateurs trouvés même si la recherche est encore en cours.
La seconde instruction permet de lancer la recherche avec la requête.

Complément de configuration Il est important d'ajouter dans le fichier de configuration Spring le langage pour effectuer le mapping entre votre classe Person locale et votre objet Person distant (Ldap) :

<bean id="fromStringConverter" class="org.springframework.ldap.odm.typeconversion.impl.converters.FromStringConverter" />
	<bean id="toStringConverter" class="org.springframework.ldap.odm.typeconversion.impl.converters.ToStringConverter" />
	<bean id="converterManager"
		class="org.springframework.ldap.odm.typeconversion.impl.ConverterManagerFactoryBean">
		<property name="converterConfig">
			<set>
				<bean
					class="org.springframework.ldap.odm.typeconversion.impl.ConverterManagerFactoryBean$ConverterConfig">
					<property name="fromClasses">
						<set>
							<value>java.lang.String</value>
						</set>
					</property>
					<property name="toClasses">
						<set>
							<value>java.lang.Byte</value>
							<value>java.lang.Short</value>
							<value>java.lang.Integer</value>
							<value>java.lang.Long</value>
							<value>java.lang.Float</value>
							<value>java.lang.Double</value>
							<value>java.lang.Boolean</value>
						</set>
					</property>
					<property name="converter" ref="fromStringConverter" />
				</bean>
				<bean
					class="org.springframework.ldap.odm.typeconversion.impl.ConverterManagerFactoryBean$ConverterConfig">
					<property name="fromClasses">
						<set>
							<value>java.lang.Byte</value>
							<value>java.lang.Short</value>
							<value>java.lang.Integer</value>
							<value>java.lang.Long</value>
							<value>java.lang.Float</value>
							<value>java.lang.Double</value>
							<value>java.lang.Boolean</value>
						</set>
					</property>
					<property name="toClasses">
						<set>
							<value>java.lang.String</value>
						</set>
					</property>
					<property name="converter" ref="toStringConverter" />
				</bean>
			</set>
		</property>
	</bean>

Le fichier pom.xml

Pour les fans de Maven, n'oubliez pas d'inclure les dépendances de Spring Core et celle de Spring-Ldap

<dependency>
	<groupId>org.springframework.ldap</groupId>
	<artifactId>spring-ldap-core</artifactId>
	<version>1.3.1.RELEASE</version>
</dependency>
<dependency>
	<groupId>org.springframework.ldap</groupId>
	<artifactId>spring-ldap-odm</artifactId>
	<version>1.3.1.RELEASE</version>
</dependency>

Psi-Probe : Open Source management and monitoring tool

Corentin Azelart — Wed, 14 Dec 2011 18:30:00 +0000

Un premier post pour présenter Psi-Probe (fork de Lambda Prode) et sa configuration. Psi-Probe est une application web (WAR) qui permet de surveiller l'ensemble des applications déployées sur un serveur Tomcat ou JBoss.

Présentation

Psi-Probe est une application web (WAR) qui permet de surveiller l'ensemble des applications déployées sur un serveur Tomcat ou JBoss. L'application présente bien et propose plusieurs écrans :

Par application :

Informations générales : nombre de requêtes, temps de réponse
Liste des sessions : supprimer à chaud, âge, adresse ip de l'occupant, etc...
Attributs de l'application (classpath, répertoire temporaire, etc...)
Mapping des pages JSP (il est possible de les forcer une recompilation à chaud, voir l'état)
Lecture des fichiers de configuration (descripteur de déploiement : web.xml)
Listing de l'ensemble des servlets et de leur charge (nombre de requêtes, temps CPU, erreurs, etc...)
Filters actifs

Par serveur :

L'ensemble des threads en cours
L'occupation des pools
Consultation des logs
Surveillance des connecteurs
Informations générales

L'installation reste simple (un WAR à déployer via le manager de votre serveur ou en copie dans le webapps), aucun fichier de configuration est nécessaire. C'est d'ailleurs la force et la faiblesse à mon sens de Psi-Probe, déploiement rapide mais configuration très sommaire. C'est un très bon outil complémentaire au manager de Tomcat. Mais l'historisation est possible que le temps de vie de l'applicatif, après vous perdez l'ensemble des informations.

Installation

L'installation nécessite la modification du fichier tomcat-users.xml afin d'ajouter les rôles suivants :

<role rolename="probeuser" />
<role rolename="poweruser" />
<role rolename="poweruserplus" />
<role rolename="manager" />
<user username="admin" password="votremotdepasse" roles="manager" />

Les différents rôles et les droits sont présents sur cette page : http://code.google.com/p/psi-probe/wiki/Features

Apres cette modification il ne reste plus qu'à redémarrer votre serveur Tomcat et déployer l'application.

Plus d'informations sur le Google Code officiel : http://code.google.com/p/psi-probe/