Blog myBlog = BlogFactory.getWordPressBlog();
Talend
Utiliser Java 7 dans Talend Open Studio
31/10/11
Il y a quelques temps que je n’avais pas retouché à Talend Open Studio. Mais le Talend Partner Summit du mois dernier m’a donné l’occasion de recroiser des connaissances, et d’en apprendre un peu plus sur l’avenir du produit (« plate-forme unifiée », « big-data avec Hadoop« , etc.). Et surtout, ce fut une journée qui m’a donné envie de me replonger un peu dans le produit. En particulier, je me suis posé la question de la possibilité de développer de nouveaux composants en utilisant Java 7. En particulier l’API NIO2 qui apporte de nombreuses fonctionnalités qu’il me semble intéressant d’exploiter :
- accès (en lecture et en écriture) à de nouvelles propriétés des fichiers : propriétaire, permissions, gestion des liens symboliques et des fichiers cachés, etc.
- surveillance native des évènements (création/modification/suppression d’un fichier)
- plus grande simplicité et meilleures performances lors de l’accès et du parcours des fichiers avec Files
- etc.
Configurer Talend Open Studio
Lancer Talend Open Studio avec Java 7
La première étape est évidemment de se procurer et d’installer le JDK 7. Une fois celui-ci installé, il faut forcer Talend Open Studio à utiliser celui-ci. Cette étape est nécessaire pour permettre l’exécution de traitements utilisant du Java 7 au sein du studio. L marche à suivre ne surprendra pas les habitués d’Eclipse : il faut modifier le fichier ini correspondant à votre programme de lancement à la racine du produit, en lui ajoutant 2 lignes permettant de préciser la JVM de lancement. Dans mon cas (sous Ubuntu), le fichier est TalendOpenStudio-linux-gtk-x86_64.ini :
1 2 | -vm /usr/lib/jvm/java-7-jdk/bin/java |
Evidemment, tant le nom du fichier que le chemin du JDK sont à adapter à votre environnement.
Enregistrer le JDK 7 dans le studio
Encore une fois, il s’agit d’une étape classique de l’utilisation d’Eclipse : il faut se rendre dans les « Préférences » du Studio (menu « Fenêtre > Préférences »). De là, le menu qui nous intéresse est « Java > JRE installés ». Il faut alors ajouter le JDK 7, et le définir comme étant celui utilisé par défaut :
Configuration Java dans Talend Open Studio
Au passage, on remarque que dans les préférences « Java > Compilateur », le niveau de compatibilité du compilateur ne va que jusqu’à la version 1.6. Cela signifie qu’on ne pourra pas utiliser dans un composant les syntaxes introduites dans Java 7 (Try with resources, « diamond », etc.). En revanche, cela n’interdit pas d’utiliser les nouvelles classes du JDK 7, ce qui nous intéresse !
Enfin, avant de quitter les préférences, faisons un détour par « Java > Style de code > Formateur », afin d’y modifier le style par défaut. En effet, Talend utilise des nom de variables particulièrement longs (car ils contiennent l’identifiant du composant), tels que tos_count_tMSSqlLastInsertId_1. Aussi, lorsque plusieurs de ces variables sont utilisées dans une même instruction, la limite par défaut de 80 caractère à vite fait de la découper en 3 ou 4 lignes, ce qui est particulièrement pénible à relire.
C’est pourquoi je recommande vivement de passer cette limite à 120, 160… voire à 1000 lignes. Le code généré n’en sera que plus facile à relire, pour comprendre ce qui ne va pas.
Utiliser du Java 7 dans Talend Open Studio
L’ensemble des préparatifs étant terminé, il est maintenant possible d’utiliser les classes de Java 7 dans Talend Open Studio :
- dans les différents composants permettant d’écrire du code directement (tJava, tJavaRow, tJavaFlex, etc.).
- en créant soit-même de nouveaux composants.
Afin de vérifier le bon fonctionnement de cette manipulation, un premier composant a été créé : le bcFileProperties. Ce composant dérivé du tFileProperties, ajoute la lecture des droits du fichier ainsi que de son propriétaire. Les sources de ce composant sont comme d’habitude disponibles sur GitHub. D’autres composants utilisant les optimisations offertes par Java 7 devraient suivre de la même manière (dès que j’aurai le temps…).
Exécution du composant bcFileProperties
Partager un projet Talend Open Studio avec git
26/03/11
Récemment, OCTO a publié deux bons billets sur les implémentations de services REST et sur leur testabilité. Je vais donc laisser ce sujet de côté pour le moment et différer le billet que je comptais écrire sur le sujet.
Depuis déjà pas mal de temps, je m’intéresse aux « forges logicielles », en particulier autour de des technologies Java. Dans ce cadre, j’ai testé plusieurs outils de suivi d’anomalies/évolutions : Mantis, JIRA, Redmine, etc.
D’après ce que j’ai pu voir, de nombreux clients utilisent Mantis pour le suivi des anomalies. Dans la forge mise en place en interne, nous utilisons plutôt Redmine (la suite des produits Altassian est également excellente, mais nécessite d’avoir le budget), en particulier pour son excellente intégration avec git :
- possibilité de lier des commits aux fiches Redmine
- pilotage automatique de la résolution et du « time-tracking » des fiches en extrayant automatiquement ces informations des commits git
- visualisation dans l’interface Redmine des diffs
- calcul et affichage de statistiques sur le dépôt du projet
Afin de pouvoir utiliser simultanément ces différents produits (Mantis du client et Redmine ou JIRA interne), j’ai pensé créer un projet Open Source permettant de synchroniser les données entre ces différents produits, en utilisant Talend Open Studio. Pour cela, il fallait donc réussir à partager ce projet en utilisant git (afin de le rendre accessible sur GitHub).
IDEA pour le développement de composants Talend
8/11/10
J’ai récemment été impressionné par la version « Community« d’IntelliJ IDEA pour le développement Java.
Même si j’ai depuis rencontré quelques problèmes avec cet IDE (au niveau de la gestion de configuration et de l’encodage des fichiers principalement), j’en suis très satisfait. J’ai donc testé la version « Ultimate« , qui m’a tout autant impressionné, et l’offre de mise à jour gratuite vers la version 10 a achevé de me convaincre : je me suis donc offert une licence de cette version.
Outre le développement Java-J2EE, j’ai voulu tester cet IDE pour le développement de composants Talend. Après quelques manipulations, il s’est avéré qu’il était beaucoup plus agréable à utiliser et puissant que le « Component Designer » fourni avec la suite Talend. Voici donc comment procéder pour avoir un très bon environnement de développement de composants :
La suite >
Créer un benchmark avec Talend Open Studio
7/09/10
Logback
Les vacances sont finies… et le ralentissement estival au travail également. Vous le remarquerez donc certainement, je vais malheureusement avoir moins de temps que cet été pour publier des articles. Mais j’ai tout de même eu le temps de regarder deux ou trois choses qui étaient sur ma « TODO » depuis longtemps.
En particulier le Framework Logback (à ne pas confondre avec le backlog de Scrum), qui est « le successeur » de Log4J :
- le fondateur du projet Log4J, Ceki Gülcü, travaille maintenant au développement de Logback
- le code initial de Logback est un refactoring du code de Log4J, avec un certain nombre d’améliorations (modularité, performances, etc.)
- la communauté de Logback est très dynamique (3 versions dans le courant du mois de juin), alors que les développements de Log4J semble ralentis : une branche 1.3 arrêtée, la branche 2.0 encore expérimentale, et la version qui a précédé la 1.2.16 (parue en avril 2010) datait de 2007
Je n’avais pas jusqu’à maintenant eu l’occasion de l’utiliser car Log4J reste la référence imposée par la DSI sur la plupart de mes projets (et il est vrai que je n’ai jamais eu de soucis avec).
Création du benchmark
Cette étude du Framework Logback a été un très bon prétexte pour détourner le fonctionnement habituel de Talend Open Studio, afin de créer un test comparatif des performances de Log4J et Logback.
J’ai ainsi développé de nouveaux composants dédiés à l’utilisation de logback dans TOS (ceux pour Log4J existaient déjà), afin de réaliser ce test. Une fois ce développement effectué, on peut s’attaquer au développement du benchmark lui-même. Et avec Talend Open Studio, c’est très simple :
- Lecture de la configuration du Framework
- Démarrage du chronomètre
- Génération d’un nombre significatif de lignes de données et log de ces lignes
- Fin du chronomètre
Benchmark Logback
Il suffit ensuite de modifier la configuration du framework pour faire varier le test : la configuration de Logback est très similaire à celle de Log4J, et la prise en main du Framework est donc immédiate.
Afin de réaliser un comparatif entre Log4J et Logback, on réalise un job identique, mais avec cette fois le logger Log4J.
Conclusion
L’avantage d’être passé par Talend pour générer ces petits traitements de test :
- La rapidité de développement (si je mets de côté le temps de développement des composants eux-mêmes) : je n’ai eu qu’à placer et à enchainer correctement les composants pour obtenir le traitement souhaité, au lieu de devoir écrire le code à la main : c’est beaucoup plus rapide.
- Le composant « tRowGenerator » me permet de faire varier très rapidement mes cas de test : niveau de log des messages envoyé fixe, cyclique, aléatoire…
- La génération automatique du code m’assure que le code est le même pour les deux Frameworks. Les différences de temps d’exécution ne proviennent donc que des Frameworks eux-mêmes.
Il ne reste plus qu’à trouver des cas de test pertinents et à les exécuter…
Découverte de Git et de GitHub
24/08/10
Après avoir utilisé pendant quelques années Subversion, qui me satisfaisait pour la gestion des sources de mes projets personnels (composants Talend, entre autres…), j’ai décidé par curiosité de tester Git, à cause des différents articles que j’ai pu lire récemment à ce sujet, dont la quasi-totalité vente les mérites.
Lorsque l’on a l’habitude d’un gestionnaire de configuration centralisé comme Subversion, la prise en main est rude… Les concepts ne sont pas les mêmes, et lorsqu’on essaye d’appliquer ceux dont on a l’habitude, on se retrouve face à quelques problèmes : mon premier réflexe a par exemple été de chercher comment lancer le « serveur Git » avant utilisation. #FAIL, comme on dirait sur Twitter…
Heureusement, vu la popularité croissante de ce système, je n’ai eu aucun mal à trouver des tutoriels qui m’ont ré-aiguillé sur la bonne voie. Je me suis ainsi rapidement mis à « la philosophie » de Git. Effectivement, j’approuve ce que j’ai pu lire : une fois qu’on l’a essayé, on a du mal à s’en passer. Je vais y revenir… Mais avant ça, voici ma liste de remerciements et des liens qui m’ont aidé à découvrir Git :
- le site officiel, pour commencer, qui propose le programme (évidemment), mais aussi un tutoriel de mise en place, le manuel ainsi que le Git Community Book.
- ProGit, ou Git Magic, deux autres ouvrages de référence disponibles en ligne
- Understand Git conceptually pour bien comprendre les concepts de Git
- Why Git is better than X, dont le titre en dit long sur le contenu : un plaidoyer sur les avantages de Git par rapport aux autres gestionnaires de configuration
- Git attitude, fournissant à ce jour deux articles très intéressants en français sur l’installation de Gitosis (même si je ne l’utilise pas) et sur l’installation de Git avec un « prompt » gérant l’auto-complétion des commandes Git.
- Le pense-bête de Nicolas de Loof sur l’utilisation de Git avec un repository central SVN, ainsi que son article sur le refactoring d’un projet SVN sous Eclipse en utilisant Git
Avec toutes ces lectures, j’ai pu me mettre correctement à Git. Les liens ci-dessus contenant toute la littérature nécessaire pour prendre un bon départ, je vous épargnerai un n-ième tutoriel qui se contenterait de recopier ce qui existe déjà…
Le premier projet personnel qui est passé de SVN à Git, ce sont les composants Talend que je développe. Chaque composant étant dans un répertoire distinct, et constitué d’une quinzaine de fichiers maximum, j’ai jugé plus simple de les regrouper dans un unique projet.
Et c’est là que les mécanismes de Git vont m’aider. Car souvent, j’ai des idées d’amélioration (ou de création) pour plusieurs composants n’ayant rien à voir : finition du bcFileOutputOOSpreadsheet, possibilité de logs conditionnelles dans tLog4J, etc.
Il existe sur SVN un mécanisme de branches, mais passer d’une branche à l’autre et effectuer des fusions de branches une fois le travail terminé n’est pas aisé :
- temps de switch relativement longs (surtout lorsque le projet a une taille conséquente). En développement Java sous Eclipse, quand je travaillais sur plusieurs évolutions fonctionnelles (branches) différentes, j’en suis venu à cloner mon projet en associant chaque projet à une branche différente pour pouvoir changer de branche en un temps acceptable.
- de très fréquents « faux » dans les conflits remontés par SVN lors des fusions (principalement en cas de suppression, de renommage ou de déplacement d’un fichier). La gestion manuelle de ces conflits sous SVN est plus que pénible.
De ce fait, j’utilisais peu ce système, et la plupart de mes commits étaient effectués dans le trunk.
Dans Git, le mécanisme de branche est beaucoup mieux géré, et est donc au coeur du système. Le réflexe à avoir sous Git, c’est « une nouvelle idée = création d’une nouvelle branche ». Si cette idée aboutit, elle sera fusionnée dans la branche principale (master). Sinon, elle sera simplement supprimée. Voici pourquoi ça marche :
- le repository Git, étant local, créer ou changer de branche est une opération très rapide, et on n’a plus besoin de cloner son projet. La « stash » (boite à idées), permet de garder en mémoire le travail en cours sur une branche avant d’en changer, sans pour autant devoir effectuer un commit
- la fonctionnalité de fusion des branches fonctionne beaucoup mieux que sous SVN. Quand le travail sur une branche est terminé, on la fusionne dans le « master » (équivalent du « trunk »). Et les mécanismes utilisés par Git, avec ses différentes stratégies de fusion, font que ça marche vraiment bien.
Après un changement dans mes habitudes de travail, je m’y retrouve donc beaucoup plus facilement avec Git, avec une branche par évolution de composant.
Dernière étape : sauvegarder mon travail, voire synchroniser mon travail entre mes différents postes de développement. Pour cela, SVN tournait sur un serveur distant et gérait très bien ce double aspect sauvegarde/synchronisation. Jusqu’ici, Git est uniquement installé sur une de mes machines de développement.
Plusieurs solutions sont possibles :
- installer git sur un serveur distant, avec un repository « bare » (cf. les nombreux tutoriels sur le travail collaboratif avec GIt que l’on trouve en ligne) et y accéder directement par le protocole Git+SSH.
- installer Gitosis (cf. tutoriel sur Git-attitude), offrant une gestion plus fine des droits sur plusieurs projets. Cette solution a beaucoup d’intérêt dans le cadre de « l’urbanisation de Git » dans le système d’informations d’une entreprise
- utiliser un hébergeur dédié, comme GitHub.
L’utilisation de GitHub est gratuite pour les projets Open Source, et payante pour les autres. Mes composants étant justement publiés en Open Source, j’ai opté pour cette dernière solution, beaucoup plus rapide à mettre en place (un formulaire de création de compte à remplir).
Outre le repository Git, la plate-forme GitHub, propose, comme SourceForge, un ensemble d’outils de suivi de projet : un historique du projet, des pages WIKI de documentation, un bugtracker…
J’ai apprécié cet aspect « Tout en un », qui manque (encore) à Talend Exchange. J’ai donc décidé de me servir de cette base pour créer le site du projet de mes composants Talend. Par rapport à Exchange, il ne contient que les composants encore vivants (dont les fonctionnalités n’ont pas été intégrées à la version de base du produit). Si vous avez des remarques (bugs) sur mes composants, ou envie de contribuer à ce projet, c’est maintenant par là-bas que ça se passe…
Il ne me reste plus qu’à éditer les liens des composants sur Exchange pour indiquer la nouvelle adresse du support…
Nouvelles fonctions d’agrégation pour Talend Open Studio
6/08/10
Spécifications
Récemment, j’ai été confronté à la problématique suivante, en apparence assez simple : un fichier contenant une liste d’opérations bancaires. Chacune de ces opérations correspond (entre autres) à un client et à un statut booléen (opération approuvée ou rejetée). Pour simplifier, on supposera qu’une opération n’est constituée que de ces deux attributs.
Le but était de trier les clients en deux catégories : ceux dont toutes les opérations ont été approuvées, et ceux ayant eu au moins une opération rejetée (l’équivalent sur le fichier d’un « GROUP BY » SQL).
Analyse
Pour réaliser cette opération, j’ai évidemment sorti mon ETL préféré, Talend Open Studio et son composant tAggregateRow. Mais là, petite surprise : il n’existe pas de fonction d’agrégation « booléenne » (et logique, ou logique, etc.). Et comme il n’existe pas de relation d’ordre sur les booléens, impossible d’utiliser directement les fonctions MIN ou MAX.
Contournement
Dans un premier temps, la solution de contournement n’a pas été difficile à trouver (il en existe d’ailleurs un certain nombre) : convertir les « true » en « 1″ et les « false » en « 0″. Avec cette transformation, la fonction booléenne « ET » est représentée par la fonction mathématique « MIN » et la fonction booléenne « OU » par « MAX » dans l’agrégation. Après cette agrégation, il suffit de faire la transformation inverse pour revenir à des booléens. En plus de la lecture du fichier et de l’écriture de la sortie, il suffit donc de 3 composants pour réaliser le traitement souhaité.
Amélioration du composant
Je suis maintenant en vacances, et j’ai donc le temps de reprendre ce problème à tête reposée. Deux composant pour faire deux transformations inverses, cela ne me satisfaisait pas. Je me suis donc penché sur l’étude du composant tAggregateRow, pour voir comment étendre ses fonctionnalités aux agrégations de champs booléens.
Je comptais en profiter de ce cas d’utilisation pour commencer un tutoriel sur le développement et l’amélioration de composants, mais je suis revenu sur cette idée : le composant tAggregateRow n’est pas des plus simples (il est en particulier constitué de deux sous-composants techniques tAggregateIn et tAggregateOut), et n’est donc à mon avis pas un bon exemple pour aborder les généralités du développement de composants, mais ce n’est que partie remise.
Je passe donc directement à la conclusion : depuis le 29 juillet 2010, vous trouverez sur Talend Exchange le composant bcAggregateRow, permettant d’agréger des champs booléens avec les fonctions booléennes « ET », « OU », et « OU EXCLUSIF ».
Tutoriel Talend : trouver les acronymes manquants
22/07/10
Ce tutoriel est la suite des deux précédents : mise en place des métadonnées et création d’un job élémentaire de nettoyage.
Lors du dernier tutoriel, nous avons créé un job très simple : lecture d’une donnée, remplacement de son contenu, et mise à jour en base. Nous allons poursuivre sur la même problématique, mais cette fois-ci, créer un job nécessitant plus de composants et de logique.
Après avoir supprimé les acronymes des billets de WordPress, je me demande si tous ceux que j’ai supprimés sont bien référencés dans le plugin « acronyms« , afin de rajouter ceux qui manqueraient (et ainsi ne pas perdre d’informations).
Encore une fois, une vérification manuelle serait longue et fastidieuse. Et encore une fois, c’est Talend qui va nous éviter ce travail…
La suite >
Job de nettoyage des articles
15/07/10
Voici la deuxième partie de ce tutoriel sur l’utilisation de TOS (rappel : première partie sur la création des métadonnées). Maintenant que les connexions aux bases de données sont configurées, nous pouvons commencer à travailler.
Nous allons donc créer un job simple, dont le but est de nettoyer les articles qui ont été migrés sur WordPress. Par « nettoyer », j’entends par exemple « supprimer les acronymes » qui avaient été insérés dans les articles. Ceux-ci n’ont plus de raison d’être, puisqu’ils sont maintenant dynamiquement renseignés par le plugin « acronyms ».
La suite >
Quand Talend m’évite un travail fastidieux
10/07/10
Au cours des différents articles de ce blog, j’ai souvent parlé des outils de Talend, dont je suis fan car ils rendent bien des services dans le travail informatique.
Aujourd’hui, j’ai l’occasion de vous présenter un cas d’utilisation plus personnel, où ces mêmes outils m’ont permis d’éviter un travail bien ennuyeux. Je vous ai présenté récemment la procédure de migration que j’ai utilisée pour passer de Dotclear à WordPress.
Cette procédure n’a pas été au bout des choses et il me restait un certain nombre de petits ajustements à effectuer :
- Migrer les liens
- Migrer les réponses aux commentaires du plugin Comback 2.0
- Supprimer les acronymes de mes anciens billets (ils sont maintenant automatiquement ajoutés par le plugin Acronyms)
- Corriger les liens internes entre les anciens billets : ils ne sont plus valables
Mis bout à bout, ces différentes actions sur 65 billets constituent un travail non négligeable… et d’un intérêt proche de 0. C’est à ce moment que Talend intervient, car il m’a permis d’automatiser ces différentes tâches.
S’agissant d’un cas d’étude simple, je pense qu’il peut constituer un bon tutoriel sur un cas d’utilisation réel de cet outil. Voici donc la première partie de ce tutoriel.
La suite >
Talend Partner Submit – Partie 4
19/04/10
Twitter 14h36 : Conférence la plus attendue: les nouvelles fonctionalités de la version 4.0.0
Outre les nouveautés que j’avais déjà listées ici, voici celles de la version sous subscription, que nous avons pu découvrir lors de cette conférence :
- Les différents outils de la suite sont maintenant intégrés dans un même environnement de développement (sous la forme de plusieurs vues dans Eclipse)
- Intégration du moteur BRMS Drools Expert, avec un composant d’application des règles. Ce composant permet de décorréler le flux de données des règles métiers. Ces dernières peuvent ainsi être modifiées par les experts métiers sans avoir à redéployer le job
- Intégration du moteur BPM Bonita
- Fonctionnalité “d’analyse d’impact”, permettant de mesurer par avance l’impact sur les jobs d’une modification que l’on souhaite réaliser (sur la structure d’une table, par exemple)
- Fonctionnalité de comparaison de jobs (ou de plusieurs versions différentes d’un même job)
- Fonctions de Haute Disponibilité (clustering de la console d’administration et des serveurs d’exécution, reprise sur erreur, etc.)
- Nouveaux algorithmes pour la qualité de données (Jaro, Q-Grams, etc.
- Liens de rejets automatiques dans le tMap
- Possibilité de connecter l’identification sur un serveur LDAP
- Prise en compte du format IDOC pour SAP
- Lancement d’un job dans une JVM séparée
- Routines “SQL-Like”
- Notifications automatiques par email
Twitter 16h33 : Présentation de la version 5 de la suite BPM Bonita Soft
Après cette conférence sur les nouveautés de la version 4.0.0 de la suite, j’ai assisté à la conférence de présentation de la nouvelle version de Bonita.
Au niveau de l’interface de développement, c’est encore une fois un produit basé sur Eclipse RCP. La présentation ne s’est pas particulièrement appesantie sur les fonctionnalités BPM elles-mêmes : je n’ai donc pas noté de fonctionnalité extraordinaire, par rapport à d’autres outils BPM (Drools Flow, jBPM, Intalio, etc. pour ne citer que des produits Open Source).
En revanche, c’est une autre fonctionnalité qui a attiré mon attention ; la possibilité de générer automatique des IHM correspondant aux workflows qu’on a créé (ce qui fait gagner un temps non négligeable dans les développements, pour tester les processus développés). Il est ensuite possible de personnaliser ces interfaces générées : déplacement des champs du formulaire, styles, etc. Le produit peut donc directement générer les écrans de l’application finale, qui peut ensuite être utilisée directement ou dans un portail.
Le seul point que je regrette, dans cette fonctionnalité, c’est que le Framework graphique n’est pas paramétrable : il s’agit forcément de GWT.
Twitter 17h11 : Dernière conférence de la journée sur le positionnement commercial de Talend et pot final!
Je passerai rapidement sur cette dernière conférence, dont je résumerai le thème à “Quels sont les avantages de Talend sur les concurrents ?”, avec des exemples de “winbacks”. Toujours en résumant : le modèle de pricing prédictif et la flexibilité de l’outil, la panoplie complète de composants inclus…
Enfin, pour clore cette journée, un goûter final permettant une dernière fois des échanges intéressants avec les autres partenaires et les membres de l’équipe Talend.
