mercredi 2 décembre 2009

Install Mysql from the zipped installation

Customize a MySQL installation from a zip file is easy :

Look in the configuration file and set the path in it correctly.


"D:\myproject\MySQL\MySQL Server 5.1\my.ini


Once done, you can set it up as a windows service using the simple command line


"D:\myproject\MySQL\MySQL Server 5.1\bin\mysqld.exe" --install
"D:\myproject\MySQL\MySQL Server 5.1\bin\mysqld.exe" --remove


Change the root password



mysqladmin -u root password NEWPASSWORD

lundi 30 novembre 2009

Configuring JNDI Javamail resource over SSL for SMTP

You declare your JAVAMAIL resource into the server.xml (or in the appropriate context file in your configuration directory) file of your tomcat :

              <Resource name="mail/MailServer" auth="Container"
type="javax.mail.Session"
mail.smtp.host="smtp.mailserver"
mail.smtp.port="465"
mail.smtp.auth="true"
mail.smtp.user="myuser"
password="mypassword"
mail.smtp.starttls.enable="true"
mail.smtp.socketFactory.class="javax.net.ssl.SSLSocketFactory"
/>


Then your resource is accessible via this URI in your webapp :

java:comp/env/mail/MailServer


Also, you must copy the two files
activation.jar and mail.jar in your tomcat common/lib server.

You may refer to the JIRA documentation where I had this hint

http://www.atlassian.com/software/jira/docs/v3.13/smtpconfig.html

mercredi 30 septembre 2009

Définition ORACLE

Définitions :

Instance :

Une instance oracle est un processus destinée à servir les données.
Listener :
Un listener est un processus gérant les connexions lourdes de sql net. Le listener n'est pas indispensable pour faire fonctionner le JDBC
Tablespace :
Un Tablespace est la définition d'un espace sur le système de fichier contenant les données. Dans les bases de données modernes, la notion de Tablespace est plus discrète, car elle ne fait pas référence au données mais au système.
User :
Un user est un espace de table. La notion de schema qui est beaucoup parlante est identique à celle du user.
Database :
Est un ensemble de schémas.

mercredi 16 septembre 2009

Débuter en JSF

Faire un tag combobox :

myCommandBean est le nom du bean mise en correspondance la combobox. #{myCommandBean.myfield} est le nom du champ qui stocke l'information.

<h:selectOneListbox  id="myCommandBean"          binding="#{myCommandBean.myfield}" size="1" >
<f:selectItems
value="#{myCommandBean.myfieldList}" />
</h:selectOneListbox>


Le fichier face-config.xml contient la configuration de Jface :

<managed-bean>        
<managed-bean-name>myCommandBean</managed-bean-name>
<managed-bean-class>com.mybusiness.MyCommandBean</managed-bean-class>
<managed-bean-scope>session</managed-bean-scope>
</managed-bean>


Ces lignes permettent de déclarer le bean de stockage des informations de la combo box dans la session. Les valeurs affectée à ce bean pourront être exploitée durant toute la session. C'est une bonne idée que d'utiliser ce scope par défaut.

public List getMyfieldList() {
List list = new ArrayList();
list.add(new SelectItem("01", "moncul"));
list.add(new SelectItem("02", "machemise"));
return list;
}


Le getter dans le bean com.mybusiness.MyCommandBean utilise une propriété HtmlSelectOneListbox


public HtmlSelectOneListbox getMyfield() {
return myfield;
}

public void setMyfield(HtmlSelectOneListbox myfield) {
this.myfield = myfield;
}

vendredi 24 juillet 2009

Générer des document openXML Word 2003/2007

Les récents standards OpenXML et Open document permettent de générer des documents sans passer par des APIs propriétaires.

Pour comprendre les formats docx de word, rien de tel que l'exemple. Le contenu en clair du fichier s'observe en dézippant le fichier word (renommert son extension .docx en .zip). Ainsi il est possible d'étudier le contenu. Ce zip comporte plusieurs fichiers :

- word/document.xml : Comporte le contenu
- word/header1.xml, word/headerx.xml: Décrit les entêtes (par section)
- word/footer1.xml : Décrit les pieds de page
- word/styles.xml : Décrit les mises en forme

Les fichiers contenus dans le zip sont nombreux. Le fichier principal est le fichier document.xml.

A priori, l'édition de son contenu ne contient rien qui soit 'user friendly', par exemple :
<w:document>
<w:body>
<w:p w:rsidR="00047630" w:rsidRDefault="00047630">
<w:pPr>
<w:tabs>
<w:tab w:val="center" w:pos="7655"/>
<w:tab w:val="right" w:pos="15451"/>
</w:tabs>
<w:ind w:right="-29"/>
<w:rPr>
<w:rFonts w:ascii="Arial" w:hAnsi="Arial" w:cs="Arial"/>
<w:b/>
<w:bCs/>
<w:sz w:val="22"/>
<w:szCs w:val="22"/>
</w:rPr>
</w:pPr>
<w:r>
<w:rPr>
<w:rFonts w:ascii="Arial" w:hAnsi="Arial" w:cs="Arial"/>
<w:b/>
<w:bCs/>
<w:sz w:val="22"/>
<w:szCs w:val="22"/>
</w:rPr>
<w:t>REGULATION :</w:t>
</w:r>
</w:p>
<w:tbl>
<w:tblPr>
<w:tblW w:w="0" w:type="auto"/>
<w:tblInd w:w="-68" w:type="dxa"/>
<w:tblLayout w:type="fixed"/>
...


Le principe de génération naturel est d'utiliser XSLT (XML Stylesheet Language Transformation) pour effectuer la transformation des données métiers brutes en un fichier document.xml.
(Toutefois, n'oubliez pas que les outils de transformation plus simple tel que Velocity peuvent être approprié dans le cas de traitement élémentaire (http://velocity.apache.org/))

Pour ne pas composer manuellement, le document.xml, mieux vaut l'extraire de votre document modèle et le copier/coller dans un fichier XSL reprenant la structure du document. Puis, en localisant endroits où ajouter les informations dans le fichier, on ajoute les valeurs de notre document XML.

Les balise XSL suivantes sont très utiles
<xsl:value-of select="/MyDoc/MyObject1/title"/> // Pour récupérer des valeurs simples

<xsl:for-each select="/MyDoc/MyObject2"> // Pour le parcours de collection

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:n2="urn:hl7-org:v3"
exclude-result-prefixes="n2 xs xsi xsl">
<xsl:output method="xml" encoding="UTF-8" indent="yes" />
<xsl:template match="/">
<w:document
xmlns:ve="http://schemas.openxmlformats.org/markup-compatibility/2006"
xmlns:o="urn:schemas-microsoft-com:office:office"
xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"
xmlns:m="http://schemas.openxmlformats.org/officeDocument/2006/math"
xmlns:v="urn:schemas-microsoft-com:vml"
xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing"
xmlns:w10="urn:schemas-microsoft-com:office:word"
xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"
xmlns:wne="http://schemas.microsoft.com/office/word/2006/wordml">
<w:body>

...
...
...
</w:body>
</w:document>
</xsl:template>
</xsl:stylesheet>


Cette pratique présente un inconvénient, du fait de la création de ce fichier par un programme, le contenu est souvent excessivement verbeux et dénué de toute forme d'intelligence. Pour générer un fichier Word à partir d'une transformation XSL, il vaut mieux comprendre un minimum la logique de ce fichier. Comprendre les balise principales est utile


  • <w:p> : Sert à commencer un paragraphe
  • <w:pPr> : Définit les paramètres du paragraphe
  • <w:rPr> : Définit les paramètres applicables au mot. Un rPr peut-être définit au niveau du wPr Lorsqu'il concerne tous les mots du paragraphe ou dans w:r lorsqu'il concerne un mot seulement
  • <w:tabs> : Permet de définir les différentes tabulations dans une paragraphe
  • <w:r> : Définit un groupe de mots
  • <w:t> : Définit un mot
  • <w:tab> : Insère une tabulation
  • <w:tbl> : Une table
  • <w:tr> : Une ligne (table row)
  • <w:tc> : Une colonne (table column)
  • <w:b> : Met le texte en gras
  • <w:u> : Souligne le texte (Attention il faut préciser le type de soulignement)
  • <w:customXml element='??'> : Est une balise qui permet de définir des structures de XML comme des information cachées, c'est utile pour structurer le document de manière invisible.


Une fois que le document est constitué, il suffit de refaire un zip et de renommer l'extension .zip en .docx. Si vous compressez l'OpenXML à l'aide de java, il faut faire attention à ce que les entries utilise le caractère '/' et non pas '\', autrement le fichier ne pourra être ouvert par la suite OpenOffice.

lundi 20 juillet 2009

JDOM vs DOM et SAX

La librairie JDOM a l'inconvénient majeur de ne pas être présente dans les APIs JAVA et de ne pas être une norme W3C. Pourtant, même si elle ne propose aucune révolution théorique, cette librairie est plus pratique à utiliser que ses consors SAX et DOM. En faits, SAX et DOM ont été développés pour couvrir être implémenté en C et C++ notamment, JDOM n'ayant pas ses limitations peut se permettre d'être plus intelligente.

Cette API est très sympathique car elle se sert des fonctionnalités de JAVA pour ne plus avoir en tête les considération de consommation de mémoire qui sont souvent problématique dans le cas des fichiers XML. Les performances s'apparentent à celle du SAX et la souplesse est proche du DOM.

Elle possède des fonctionnalités qui s'apparente à XPath (mais en plus simple). JDOM peut-être utilisé pour des transformations de noeuds non prises en compte trivialement par XSL (Déplacements de noeuds, clonages, modification de structure hiérarchiques)

Et pour ceux qui doutent encore, il a été décidé que JDOM sera intégré au futures JDK.
Alors lancez vous !

Exemple de parsing :


SAXBuilder builder = new SAXBuilder();
Document doc = builder.build(xslIs);


Exemple de sérialisation :

XMLOutputter xmlOutputter = new XMLOutputter();
xmlOutputter.output(doc, fos);


Exemple de sérialisation :

XMLOutputter xmlOutputter = new XMLOutputter();
xmlOutputter.output(doc, fos);


Exemple de copie de noeud :

Element cloneElement = (Element) originalElement.clone();
parentElement.addContent(cloneElement);


C'est souvent beaucoup plus simple que XSL dans le cas de transformations complexes !

vendredi 3 juillet 2009

Configurer maven à travers un proxy

Voici le fichier de configuration pour passer à travers un proxy
<settings>
<localRepository>d:/repo-maven</localRepository>
<proxies>
<proxy>
<active>true</active>
<protocol>http</protocol>
<host>proxy.mycorp.com</host>
<port>8080</port>
<nonProxyHosts>www.google.com|*.somewhere.com</nonProxyHosts>
</proxy>
</proxies>
</settings>

vendredi 26 juin 2009

Terminologie de l'informatique

L'informatique est une industrie relativement récente et la plupart de son vocabulaire a été emprunté à des corps de métier plus anciens. La tendance logomachique du secteur n'est plus à démontrer. En général, le vocabulaire utilisé est abscons et imprécis, il est toujours difficilement compréhensible pour le néophyte. A mon avis, il y a deux raisons à cela :


  • Le développement du business (Un business est d'autant plus juteux qu'il est occulte) C'est ainsi que les astrologues vivaient grassement il y a quelques siècles.

  • Un complexe d'infériorité. Le boums de l'informatique a connu une période où les jeunes étaient dominant. Et tout le monde se congratulait d'être cadre, d'être ingénieur. Simplement, il est naturel de crâner un peu quand on est jeune.



MOA :
Maitrise d'ouvrage. Le terme maitrise d'ouvrage vient des métiers du bâtiment. Anciennement, il s'agissait tout simplement du commanditaire de la réalisation. C'est celui qui possède l'argent et gère des budgets.

commanditaires est un terme moins ambigu.

MOE :
Maîtrise d'œuvre vient également du bâtiment. Cet acteur prend la direction technique de la réalisation. La MOE prend en charge la gestion du projet ainsi que la réalisation.
direction de réalisation est un terme moins ambigü

Architecte :
L'architecte est un concepteur. Ce mot est très pompeux, attendu que à l'inverse du bâtiment un architecte peut et doit mettre la main à la pâte dans la réalisation. Il effectue des choix techniques orientant le choix des technologies, il choisi les modes de réalisation, défini le plan d'implantation du système, contraintes du projets. Il y a deux catégories d'architecte :

- Architectes système : Défini les plan d'implantation du des serveurs
- Architecte logiciel : Effectue des choix technique

direction de réalisation est moins ambigu

Gestion de configuration :
La gestion de configuration est une notion empruntée à l'industrie. Ce terme désigne les processus pour gérer le différentes configurations de produits physique. L'informatique a repris ce vocabulaire pour la gestion des sources, mais la maturité aidant il est devenu obsolète de parler de gestion de configuration quand il s'agit de gérer des code sources : appelons un chat un chat.

Le métier :
Le métier représente les concepts propres au commanditaire. La polysémie du mot métier est intrinsèque, mais il s'agit le plus généralement de tout ce qui ne concerne pas la technique informatique.

L'utilisation de l'anglicisme business est stupide car le business en anglais recouvre deux notions : les affaires et le métier. Autant s'en passer

Les beans :
Le bean est du tartalacrème de chez tartalacrème. il fut un temps où tout était bean. Avec le temps, son sens est devenu plus précis : Il s'agit d'une classe possédant des accesseurs et dépourvue de code de traitement.

dimanche 21 juin 2009

Appliquer des patchs sur des répertoires

En ayant modifié un repertoire hors de conf, comment répercuter les modifications sur la conf.


-n pour dry-run (faire le test)
-C pour exlure les fichier de conf

Cette commande pour voir les nouveaux fichiers


rsync -n -r -v -u -C src dst


puis


rsync -r -v -u -C src dst

Effectue vraiment l'opération

Patcher sur un repertoire n'est généralement pas une opératio automatique.

Cette commande pour voir les fichiers à supprimer


rsync -n -r -v --del -C src dst


Puis


rsync -r -v --del -C src dst

applique la modification

diff permet de créer des patch

patch permet de les appliquer.

Eclipse permet d'appliquer des patch sur des répertoire en entier.

jeudi 18 juin 2009

La voie du milieu dans le développement informatique

Un jour, vous vous êtes peut-être retrouvé, comme moi, piégé dans une querelle surréaliste où deux "experts" s'entretuaient à propos du StringBuffer.append() et de l'opérateur + sur une String.

En voyant la rage et l'énergie dépensée, vous vous êtes peut-être dit comme moi : peut-être que c'est important ? Et puis, vous vous êtes repris : Non, ça ne peut-pas être important ! Mais alors, comment lutter contre le brassage de vent ? Car en luttant pour le bon sens, on s'aperçoit que la voie la plus raisonnable n'est pas la plus facile à défendre. Selon moi, l'industrie informatique est en passe d'atteindre la maturité, mais certains comportements radicaux de son adolescence subsistent.

Pour atteindre la sagesse, il convient de considérer les choses avec du recul. Il ne suffit pas d'être rigoureux, il ne suffit pas d'être couvert par les responsable hiérarchique pour bien travailler. L'intelligence n'est pas une vertue strictement positive, dans le sens ou elle constitue un cheminement logique, c'est au contraire la capacité à s'adapter à toutes les situation qui défini le mieux l'intelligence.

L'organisation typique d'une entreprise de développement informatique est la suivante :

  • Un bureau des méthodes
  • Un chef de projet de réalisation
  • Un architecte technique
  • Les développeurs


Chacun de ces acteurs sont humains et recherchent à travers leur travail la reconnaissance d'un rôle dans la société. Cet objectif inavoué (et respectable) ne doit pas être oublié pour comprendre des aberrations qu'on rencontre dans la vie des entreprises. Aussi, je voudrais m'attarder à travers l'entreprise sur le sujet tabou des affects et faire de la psychologie appliquée. Les goût qui orientent les vocations de chacun et donc, à tel type de métier correspond un profil psychologique.

Ces acteurs défendent chacun des intérêts propres et déclenchent souvent des conflits d'intérêts, où s'invite le passionel :

Le bureau des méthodes


Le bureau des méthodes a deux objectifs :
  • Améliorer la maintenabilité : Donner des normes, poser des exigences de qualité.
  • Améliorer la productivité : Fournir des outils et des frameworks, une configuration standard.

Ces deux vocations sont contradictoires. Pour contrer cet antagonisme de surface, suivre la voie du milieu est la meilleure option, mais c'est aussi la plus difficile.

Parce qu'il s'agit d'orienter subtilement les équipes de développement, pour le bureau des méthode, la qualité de la relation avec les équipe de développement est cruciale. Elle passe essentielement par des échanges importants. Une communication ni trop souple, ni trop dure est la solution. Les mails sont utiles, mais rien ne vaut les moyens plus informels pour se comprendre correctement, le téléphone et les réunions. Dans toutes les entreprises que j'ai connues, il n'en est pas une seule ou la relation entre le bureau des méthode et les équipes de réalisation ai été complétement détendue. Ces frictions sont naturelles et inévitable dans une certaine mesure, mais les conflits ouverts ou larvés sont toujours néfastes. Il faut les éviter à tout prix. Il vaut mieux faire des recommandations que des impositions.

Le travers d'un bureau des méthodes est d'alourdir inconsidérément le processus. Le meilleur moyen de ne pas se couper de la réalité du terrain est d'appliquer à soit même ce qui est imposé dans le développement des projets réels, au sein même de l'équipe méthode.

Le chef de projet


Le rôle d'un chef de projet est :
  • Optimiser le cout de réalisation
  • Augmenter le bénéfice

Encore un fois, dans le cas du chef de projet, il faut naviguer entre deux eaux. Ce n'est pas un rôle facile, car il n'est pas strictement borné en terme d'affectation. Un chef de projet ne doit pas s'enliser dans la technique et perdre son pragmatisme. A l'inverse, sombrer dans la bureaucratie et ne plus comprendre le langage des équipe qu'il dirige constitue un autre travers. Un chef de projet doit mesurer les impacts des modifications demandées et ne pas rester dans un langage utilisant seulement tache, reste à faire, quand etc. Sa vision doit être synthétique. Le distance raisonnable est une affaire d'expérience, ni trop loin, ni trop proche.

L'architecte


Le rôle de l'architecte consiste à :
  • Effectuer des choix techniques
  • Expliquer et argumenter les solutions

Contrairement au autre rôle, un architecte n'a pas besoin de se préserver d'une schizophrénie. Son rôle est tout à fait positif et requiert essentielement de la pédagogie.
Un architecte technique tend à concevoir ses projets à partir de sa seule expérience. Ce n'est pas mauvais en soit, mais cela conditionne l'hermétisme à d'autres solutions plus pragmatiques. Il faut éviter de sacraliser sa propre expérience. Et puis, c'est une mauvaise communication de commencer à présenter ses solutions par : "Croyez-en mon expérience". La capacité de remise en cause est fondamentale pour éviter les tentacules de la déréliction. Mieux vos décliner patiemment les avantages de votre solution.

Le développeur


Le rôle d'une développeur est de produire un programme conforme à ce qui lui a été demandé.
Le travers d'un développeur est de rechercher la solution immédiate à ses problèmes, sans se préoccuper du long terme. Pour bien faire, il faut penser à ses successeurs. L'inverse peut également se produire, lorsqu'un développeur souhaite utiliser une technologie uniquement pour progresser dans ses connaissances.

Quelque soit votre place dans l'organisation, la meilleure option est de suivre la voie du milieu.
La voie du milieu doit avant tout éviter les écueils typiques :

- Auto référence :
Avec l'avènement d'internet, les experts techniques (le bureau des méthodes) ont tendance à prendre pour argent comptant ce qui est affirmé sur les experts. Ce genre de pratique est tellement généralisé, que les publications d'experts reprennent souvent ce qu'il ont lus d'autres experts : La boucle est bouclée. Cette auto-référence décorelle les vérités d'internet de celle du monde réel.

- Généralisation de l'automatisation :
Dans la recherche de la qualité, l'utilisation des outils fournissant des indicateurs s'est généralisée. De plus en plus fréquement, la qualité d'un code est appréciée suivant des paramètres automatique. Il est bon de rappeler, tout ce qui est automatique se substitue rarement à l'intelligence. La conformité checkstyle n'est en rien la garantie d'un "bon" code. Rien ne vaut un audit de code utilisant de la matière grise.

- Complexité inutile :
L'informatique s'applique toujours à la modernisation. Tout les acteurs ont économiquement des intérêts à promouvoir la nouveauté. Confondre la nouveauté avec l'efficacité est un mensonge défendu à tous les niveaux du secteur informatique. C'est pourtant clairement faux, ne l'oubliez pas. La plupart des projets de modernisation visent à améliorer l'efficacité. C'est seulement en atteignant cet objectif que vous ferez un client heureux.


- Jargonnage :
L'architecture en informatique est un concept flou. Généralement, il s'agit de conception sous toute ces formes : du découpage, des choix techniques, mais ce peut-être aussi des choix d'organisation qui concerne la gestion de projet.

Ce statut incommode manque parfois de respectabilité. Selon moi, le soucis principal des architectes est de se positionner correctement pour avoir une autonomie importante. Il existe deux manières pour ce faire :
  • la pédagogie (qui est lente)
  • La rétention d'information et le dirigisme envers le développeur


Bien évidement la pédagogie nécessite plus de patience mais elle paie mieux sur le long terme.

Méfiez vous systématiquement de quelqu'un qui utilise trop d'acronymes. Comme dit Pascal, ce qui se conçoit bien s'énonce clairement.

- Exploitation de la peur :
La peur est utilisée pour saigner les clients. Elle sert à vendre des "optimisations" à priori. Alourdissant inutilement l'architecture. Lorsqu'une optimisation est proposée, elle doit correspondre à une volumétrie réelle. Si vous n'êtes pas google, il y a de fortes chances que les meilleures réponses aux problèmes de performance consistent à modifier les processus.

La peur intervient également dans le domaine de la sécurité informatique. Ce n'est pas un hasard si les audits de sécurité sont parmi les plus chers qui soient. Ils font intervenir uniquement des experts. Rappelez-vous simplement ceci, aucune sécurité n'est infaillible. Un chantier de sécurisation sert à placer curseur plus ou moins haut. Si une faille est découverte, cela ne suffit pas à démontrer que le système est mauvais, l'inverse est évidement vrai aussi. la sécurité n'est pas une mesure binaire.

mardi 16 juin 2009

Ouvrir un document en java

Pour ouvrir un document sans préciser entièrement la ligne de commande.

Ceci permet de déléguer la responsabilité d'assigner un programme à un type de document. Pour ouvrir un PDF.

L'article source

Sous windows :

public class ShowPDF {
public static void main(String[] args) throws Exception {
Process p =
Runtime.getRuntime()
.exec("rundll32 url.dll,FileProtocolHandler c:/pdf/mypdf.pdf");
p.waitFor();
}
}



Sous linux :

public class ShowPDF {
public static void main(String[] args) throws Exception {
Process p =
Runtime.getRuntime()
.exec("mimopen c:/pdf/mypdf.pdf");
p.waitFor();
}
}


Pour éditer l'association des fichiers modifier ce fichier :
/usr/share/application-registry/gnome-vfs.applications

vendredi 12 juin 2009

Appfuse pour le développement rapide d'application JAVA

Appfuse aide au développement rapide des applications web java à l'aide de technologies open source.

A l'aide de maven vous pouvez simplement initiez un projet de par la commande mvn archetype:generate et selectionner :



  • appfuse-basic-jsf

  • appfuse-basic-spring

  • appfuse-basic-struts

  • appfuse-basic-tapestry

  • appfuse-core

  • appfuse-modular-jsf

  • appfuse-modular-spring

  • appfuse-modular-struts

  • appfuse-modular-tapestry


Les avantages :
Le développement est accéléré par une gestion des utilisateurs et des rôles déjà implémentée. Elle nécessite peu d'adaptation pour se conformer des cas d'utilisations réels d'une application de gestion.
Les controlleurs de base sont assez souples pour se conformer à toutes les navigations rencontrées dans les application de gestion.
Les DAO et manager Générique accélère notablement le cas basique d'édition d'un fomulaire.
L'adaptation graphique est peu couteuse.

Les inconvénients :
Les prototypes proposés par maven sont assez mauvais :
Le développement avec l'IDE eclipse est difficile à initialiser pour fonctionner avec WTP.
Le pom est pollué par tout un tas de fonctions qui ne sont pas nécessaires quand l'objectif est la rapidité. L'enrichissement progressif aurait été préférable.
Le mécanisme de properties est lourd et ne fonctionne bien qu'avec maven, voir lourdingue et freine la rapidité de développement.
Le prototype maven utilisant la dépendance de war est très peu lisible et n'apporte pas grand chose.

En réalité, le travail avec appfuse pour une petite application commence par les suppression des fonctions ne concernant pas directement la productivité : checkstyle, PMD, aspect etc.

La documentation est encore légère et manque d'exemples complets.

Conclusion :

Appfuse n'est pas encore un RAD, il n'est pas révolutionnaire non plus. Le vrai problème de appfuse est la manière dont il est exploité avec maven. Cependant, il peu constituer la première inspiration pour créer un framework maison. Les archétypes maven peuvent difficilement être considérés comme un framework RAD.

A mon sens, les archetypes fournis souffrent d'une conception trop théorique. Ces handicaps sont particulièrement gênants lorsqu'il s'agit d'être rapidement productif. Néamoins, après quelques adaptations, ces prototypes peuvent remplir leurs objectifs de rapidité.

jeudi 26 février 2009

Effectuer une compie de synchronisation

La commande rsync permet d'effectuer une copie de synchronisation sous Linux. Cette commande permet notamment d'effectuer des backup de vos données (Musique, films, images etc.) mais elle peut également servir à synchroniser les codes sources de vos programmes sans utiliser de gestionnaire de configuration.

Il existe de nombreuses options que l'on peut consulter à l'aide de man.


Exemples :

Copie d'une arborescence entière :

rsync -rvu /srcdir /dstdir


Cette commande permet de copier les fichiers et leur arborescence de /srcdir vers /dstdir
-r pour récursif
-v pour verbose
-u pour update (Autrement les fichiers qui n'ont pas été modifié sont recopiés)

L'option -n permet de simuler l'opération en listant les modifications qui seront effectuées.

Copie des fichiers L* et leur arborescence dans vers /dstdir :


rsync -rvu -f"+ */" -f"+ L*" -f"- *" /srcdir /dstdir

Pour copier la structure de repértoire seulement

rsync -av --include='*/' --exclude='*' src dest

Pour synchroniser un projet maven à partir d'un code source modifié sur une machine n'ayant pas accès au gestionnaire de configuration.

rsync -rnvu --delete -c --exclude=.svn --exclude=target/ /elsewhere/mydistantproject/ /home/myworkspace/mylocalproject/

Convertir des fichiers stéréo en mono

Le logiciel sox sous linux permet d'effectuer une conversion de stéréo vers mono.
Il permet également de doser le mixage.
Pour ne recopier que le canal gauche
sox -c1 input.mp3 output.mp3 remix 1

Pour ne recopier que le canal droit
sox -c1 input.mp3 output.mp3 remix 2

Pour transformer en mono
sox -c1 input.mp3 output.mp3 remix -


Pour effectuer le transformation de manière globale.

find *.mp3 -exec sox -c1 '{}' 'left/{}' remix - \;

mercredi 25 février 2009

Comment parcourir récursivement un répertoire pour appliquer des traitement en C

Lorsque l'on veut appliquer un traitement à des fichiers en parcourant l'arborescence. Il y a la possibilité d'utiliser la commande find associé à - exec.

Voici quelques exemples du monde réel world FIND usage


Copie dans un répertoire
find / -type f -name *.jpg -exec cp {} . \;
find /home/hudson/repertoire-data/ -type f -regex ".*ARTICLE_O.*" -exec echo {} \;
find /home/hudson/repertoire-data/ -type f -regex ".*ARTICLE_[^O].*" -exec echo {} \;
find . -type f -size +10000 -exec ls -al {} \;
Récherche des fichiers accédés il y a un jour
find . -atime +1 -type f -exec mv {} TMP \;
find . -name "-F" -exec rm {} \; # a script error created a file called -F
find . -exec grep -i "vds admin" {} \;
find . \! -name "*.Z" -exec compress -f {} \;
find . -type f \! -name "*.Z" \! -name ".comment" -print | tee -a /tmp/list
find . -exec chmod 775 {} \;
find . -user xuser1 -exec chown -R user2 {} \;
find . -exec grep PW0 {} \;
find . -exec grep -i "pw0" {} \;
find . -atime +6
find . -atime +6 -exec ll | more
find . -atime +6 -exec ll | more \;
find . -name auth*
find . -exec grep -i plotme10 {} \;
find . -ls -exec grep 'PLOT_FORMAT 22' {} \;
find . -print -exec grep 'PLOT_FORMAT 22' {} \;
find . -print -exec grep 'PLOT_FORMAT' {} \;
find . -print -exec grep 'PLOT_FORMAT' {} \;
find ./machbook -exec chown 184 {} \;
find . \! -name '*.Z' -exec compress {} \;
find . \! -name "*.Z" -exec compress -f {} \;
find /raid/03c/ecn -xdev -type f -print
find /raid/03c/ecn -xdev -path -type f -print
find / -name .ssh* -print | tee -a ssh-stuff
find . -name "*font*"
find . -name hpmcad*
find . -name *fnt*
find . -name hp_mcad* -print
find . -grep Pld {} \;
find . -exec grep Pld {} \;
find . -exec grep Pld {} \;
find . -exec grep PENWIDTH {} \; | more
find . -name config.pro
find /raid -type d -name ".local_sd_customize" -print
find /raid -type d -name ".local_sd_customize" -ok cp /raid/04d/MCAD-apps/I_Custom/SD_custom/site_sd_customize/user_filer_project_dirs {} \;
find /raid -type d -name ".local_sd_customize" -exec cp /raid/04d/MCAD-apps/I_Custom/SD_custom/site_sd_customize/user_filer_project_dirs {} \;
find . -name xeroxrelease
find . -exec grep xeroxrelease {} \;
find . -name xeroxrelease
find . -name xeroxrelease* -print 2>/dev/null
find . -name "*release*" 2>/dev/null
find / -name "*xerox*" 2>/dev/null
find . -exec grep -i xeroxrelease {} \;
find . -print -exec grep -i xeroxrelease {} \;
find . -print -exec grep -i xeroxrelease {} \; > xeroxrel.lis
find . -exec grep -i xeroxrel {} \;
find . -print -exec grep -i xeroxrel {} \;
find . -print -exec grep -i xeroxrel {} \; | more
find /raid/03c/inwork -xdev -type f -print >> /raid/04d/user_scripts/prt_list.tmp
find . -exec grep '31.53' {} \;
find . -ls -exec grep "31/.53" {} \; > this.lis
find . -print -exec grep "31/.53" {} \; > this.lis
find . -print -exec grep 31.53 {} \; > this.lis
find . -exec grep -i pen {} /;
find . -exec grep -i pen {} \;
find . -print -exec grep -i pen {} \; | more
find . -exec grep -i pen {} \;
find . -atime +6 -exec ll | more \;
find . -atime +6 -exec ll \;
find . -atime +6 -exec ls \;
find . -atime +30 -exec ls \;
find . -atime +30 -exec ls \; | wc -l
find . \! -name '*.Z' -exec compress -f {} \;
find . -name 'cache*' -depth -exec rm {} \;
find . -name 'cache*' -depth -print | tee -a /tmp/cachefiles
find . -name 'cache[0-9][0-9]*' -depth -print | tee -a /tmp/cachefiles
find . -name 'hp_catfile' 'hp_catlock' -depth -print | tee -a /tmp/hp.cats
find . -name 'hp_catfile' -name 'hp_catlock' -depth -print | tee -a /tmp/hp.cats
find . -name 'hp_cat*' -depth -print | tee -a /tmp/hp.cats
find . -name 'hp_cat[fl]*' -depth -print | tee -a /tmp/hp.cats
find /raid -name 'hp_cat[fl]*' -depth -print
find . \! -name '*.Z' -exec compress -f {} \;
find . -name '*' -exec compress -f {} \;
find . -xdev -name "wshp1*" -print
find . -xdev -name "wagoneer*" -print
find . -name "xcmd" -depth -print
find /usr/contrib/src -name "xcmd" -depth -print
find /raid -type d -name ".local_sd_customize" -exec ls {} \;
find /raid -type d -name ".local_sd_customize" \
-exec cp /raid/04d/MCAD-apps/I_Custom/SD_custom/site_sd_customize/user_filer_project_dirs {} \;



L'inconvénient de la méthode find est qu'elle passe par l'interpréteur de commande pour lancer le shell ce qui peut-être problématique lorsque l'on souhaite traiter des fichiers ayant des noms comportant des espaces, guillemets, parenthèse etc.

La seconde solution est de faire un programme C pour appliquer son traitement. La librairie ftw adresse spécialement ce type de problème, elle fonctionne comme la commande find.

Ses paramètres sont
* Le chemin de départ de la récursion
* La méthode à appeler pour chaque élement (Le nom peut varier mais elle doit retourner un entier et avoir trois arguments.
int nomdemethode(const char *path, const struct stat *ptr, int flag))

Voici un exemple :

#include <ftw.h>
#include <stdio.h>

int process(const char *path, const struct stat *ptr, int flag)
{
printf("Found\n path:%s\nflag%d\n", path, flag);
return 0;
}

int main(int argc, char *argv[]) {
if(argc == 1){
ftw(".", process, 1);
}
else{
ftw(argv[1], process, 1);
}
return 0;
}


Exemple d'utilisation :

Je voulais appliquer un traitement audio à de nombreux fichiers par le biais de la commande sox, malheureusement ce programme n'avait pas de fonction qui permettait d'effectuer des traitements par lots.

Les noms de fichiers comportaient aussi de nombreux caractères spéciaux qui empêchaient l'utilisation de la commande find. J'ai adapté le source du programme.

- Renommer la méthode main de sox par une méthode ancienmain
- Utiliser la méthode main du type présenté plus haut
- Créer une méthode appelée à chaque fois que ftw rencontre un nouvel élément on l'appelle process.

int process(char *dirname, const struct stat *status, int type){
if(!(type == FTW_F && strstr(dirname,".mp3")!=NULL&& strstr(dirname,"/L-")==NULL)){
return 0;
}

// Ici nous construisons les paramètres qui servent pour appeler l'ancien main.


char * params[6];
char nom_transforme[200];
struct stat s;
nom_transforme[0]=0;
params[0]="sox";
params[1]="-c1";
// ...
params[4]="remix";
params[5]="1";

/*
Les programmes ne sont généralement pas fait pour fonctionner en batch
aussi, il est nécessaire d'initialiser les variable globale à chaque appel.
Ce sont celle qui sont en dehors de toute méthode.
**/
mavarglobale1=0;
mavarglobale2=1;
...
mavarglobale3 = NULL;
mavarglobale4 = 0;

// Appel de l'ancien main
ancienmain(6,params);
}


Il ne s'agit clairement pas d'un controunement facile, et la volumétrie des fichiers doit clairement compenser l'effort de programmation par rapport à un appel de find.

Montage Samba Mandriva

Comment monter un partage samba en ligne de commande sous mandriva.

Installer le rpm mount-cifs

taper
mount.cifs //Monserver/monpartage /mnt/monpointdemontage -ouser=monuser

vendredi 20 février 2009

Utilisations des threads

Il existe deux techniques d'utilisation des thread en JAVA :

* Implémenter l'interface Runnable
* Etendre la classe thread.

Dans l'optique de faire un code robuste, je recommande d'implémenter l'interface Runnable, elle évite de se perdre dans la profusion de méthodes offertes par la classe Thread.

Les threads servent à paralléliser les tâches. Deux opérations clés sont importantes.

* Le départ
* La synchronisation (jointure)

Le plus délicat est de comprendre l'utilisation du wait et du notify. Pour être utilisé le wait et le notify doivent être placé sur la même classe (Ici le ThreadGroup)


Ce bloc lance 25 threads

// Ici nous construisons sans les déclencher tous les thread dont nous avons besoins
List<thread> threads = new ArrayList<thread>();
ThreadGroup threadGroup = new ThreadGroup("MyThreadList");
for (int i = 0; i < thread =" new" thread =" new"> 0) {
System.out.println("Threads restants : " + threadGroup.activeCount());
// Attente d'une nçotification
threadGroup.wait();
}
}



Voici l'implémentation de Runnable


public class MyThread implements Runnable {

public MyThread(ThreadGroup tg) {
threadGroup = tg;
}

public void run() {
System.out.prinln("Effectue le traitement");

// Ici le ThreadGroup est notifié
synchronized (threadGroup) {
// Notification du parent
threadGroup.notify();
}
}

jeudi 19 février 2009

Encodage et maven

Si l'on assemble les projets maven sur des machines ayant des encoding différents (par exemple une application développée sous windows et assemblé sur LINUX UTF-8), il peut y avoir des problèmes d'encodage de fichier se manifestant par caractères inconnu aparaissant à l'écran.

Pour ne pas avoir de soucis, il est nécessaire de préciser l'encoding du compilateur et celui de l'assembleur ressources dans le descipteur de projet pom.xml .

<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<encoding>ISO-8859-1</encoding>
<source>1.5</source>
<target>1.5</target>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-resources-plugin
</artifactId>
<configuration>
<encoding>ISO-8859-1</encoding>
</configuration>
</plugin>

lundi 26 janvier 2009

Traiter les espace dans les lignes de commande

Le traitement des espaces dans les lignes de commande peut-être délicat dans les lignes de commande linux.

mkdir convert/
ls *.dat|
while read i
do
i=${i/ /espace}
i=${i/ /espace}
i=${i/ /espace}
i=${i/ /espace}
i=${i/ /espace}
i=${i/ /espace}
i=${i/ /espace}
i=${i/ /espace}
i=${i/ /espace}
i=${i/espace/\\ }
i=${i/espace/\\ }
i=${i/espace/\\ }
i=${i/espace/\\ }
i=${i/espace/\\ }
i=${i/espace/\\ }
i=${i/espace/\\ }
i=${i/espace/\\ }
i=${i/espace/\\ }
echo sox -c1 $i convert/$i remix 1
done